def load_portconf(self):
"""
Load port config for this virtual machine
"""
self.conf = PortConf()
self.conf.load_ports_config(self.vm_name)
self.ports_cfg = self.conf.get_ports_config()
def __init__(self, crb, serializer):
self.NAME = 'dut' + LOG_NAME_SEP + '%s' % crb['My IP']
super(Dut, self).__init__(crb, serializer, self.NAME)
self.host_init_flag = False
self.number_of_cores = 0
self.tester = None
self.cores = []
self.architecture = None
self.ports_info = []
self.conf = PortConf()
self.ports_map = []
self.virt_pool = None
# hypervisor pid list, used for cleanup
self.virt_pids = []
def __init__(self, crb, serializer, dut_id):
print("********** MyDut python file first line")
self.NAME = 'dut' + LOG_NAME_SEP + '%s' % crb['My IP']
super(MyDut, self).__init__(crb, serializer, self.NAME, alt_session=True, dut_id=dut_id)
self.host_init_flag = False
self.number_of_cores = 0 # changed here
self.tester = None
self.cores = []
self.architecture = None
self.ports_info = []
self.conf = PortConf()
self.ports_map = []
self.virt_pool = None
# hypervisor pid list, used for cleanup
self.virt_pids = []
self.socket =0 # changed here
def __init__(self, host, domain_id, bus_id, devfun_id):
super(Atwood, self).__init__(host, domain_id, bus_id, devfun_id)
self.tp_path = "~"
self.host = host
# load port config
portconf = PortConf(PORTCONF)
portconf.load_ports_config(host.crb['IP'])
pci_addr = ':'.join((domain_id, bus_id, devfun_id))
if not portconf.check_port_available(pci_addr):
raise PortConfigParseException("Atwood must configured")
port_cfg = portconf.get_ports_config()[pci_addr]
if 'tp_ip' not in port_cfg.keys():
raise PortConfigParseException("Atwood must configure test point ip")
if 'passwd' not in port_cfg.keys():
raise PortConfigParseException("Atwood must configure host password")
crb = {}
crb['IP'] = port_cfg['tp_ip']
crb['pass'] = port_cfg['passwd']
if 'tp_path' in port_cfg.keys():
self.tp_path = port_cfg['tp_path']
# create addtional session
self.ctrl_crb = CtrlCrb(crb)
def __init__(self, host, domain_id, bus_id, devfun_id):
super(BoulderRapid, self).__init__(host, domain_id, bus_id, devfun_id)
self.tp_path = "~"
self.sec_port = False
self.host = host
# load port config
portconf = PortConf(PORTCONF)
portconf.load_ports_config(host.crb['IP'])
pci_addr = ':'.join((domain_id, bus_id, devfun_id))
if not portconf.check_port_available(pci_addr):
raise PortConfigParseException("BoulderRapid must configured")
port_cfg = portconf.get_ports_config()[pci_addr]
# secondary port do not need reinitialize
if 'sec_port' in port_cfg.keys():
print GREEN("Skip init second port test point session")
if 'first_port' not in port_cfg.keys():
raise PortConfigParseException(
"BoulderRapid second port must configure first port")
# find net_device by pci_addr
first_addr = port_cfg['first_port']
port_info = self.host.get_port_info(first_addr)
if port_info is None:
raise PortConfigParseException(
"BoulderRapid first port not found")
# get addtional session
netdev = port_info['port']
self.ctrl_crb = netdev.get_control()
self.sec_port = True
return
if 'tp_ip' not in port_cfg.keys():
raise PortConfigParseException(
"BoulderRapid must configure test point ip")
if 'passwd' not in port_cfg.keys():
raise PortConfigParseException(
"BoulderRapid must configure host password")
crb = {}
crb['IP'] = port_cfg['tp_ip']
crb['pass'] = port_cfg['passwd']
if 'tp_path' in port_cfg.keys():
self.tp_path = port_cfg['tp_path']
# create addtional session
self.ctrl_crb = CtrlCrb(crb)
class MyDut(Crb):
"""
A connection to the CRB under test.
This class sends commands to the CRB and validates the responses. It is
implemented using either ssh for linuxapp or the terminal server for
baremetal.
All operations are in fact delegated to an instance of either CRBLinuxApp
or CRBBareMetal.
"""
PORT_MAP_CACHE_KEY = 'dut_port_map'
PORT_INFO_CACHE_KEY = 'dut_port_info'
NUMBER_CORES_CACHE_KEY = 'dut_number_cores'
CORE_LIST_CACHE_KEY = 'dut_core_list'
PCI_DEV_CACHE_KEY = 'dut_pci_dev_info'
def __init__(self, crb, serializer, dut_id):
print("********** MyDut class file call here")
self.NAME = 'dut' + LOG_NAME_SEP + '%s' % crb['My IP']
super(MyDut, self).__init__(crb,
serializer,
self.NAME,
alt_session=True,
dut_id=dut_id)
#changes to be made here
self.host_init_flag = False
self.number_of_cores = 0
self.tester = None
self.cores = []
self.architecture = None
self.ports_info = []
self.conf = PortConf()
self.ports_map = []
#self.virt_pool = None
# hypervisor pid list, used for cleanup
self.virt_pids = []
def init_host_session(self, vm_name):
"""
Create session for each VM, session will be handled by VM instance
"""
pass
def new_session(self, suite=""):
"""
Create new session for dut instance. Session name will be unique.
"""
pass
def close_session(self, session):
"""
close new session in dut instance
"""
pass
def change_config_option(self, target, parameter, value):
"""
This function change option in the config file
"""
pass
def set_nic_type(self, nic_type):
"""
Set CRB NICS ready to validated.
"""
self.nic_type = nic_type
if 'cfg' in nic_type:
self.conf.load_ports_config(self.get_ip_address())
def set_toolchain(self, target):
"""
This looks at the current target and instantiates an attribute to
be either a CRBLinuxApp or CRBBareMetal object. These latter two
classes are private and should not be used directly by client code.
"""
pass
def mount_procfs(self):
"""
Mount proc file system.
"""
mount_procfs = getattr(self, 'mount_procfs_%s' % self.get_os_type())
mount_procfs()
def mount_procfs_linux(self):
pass
def get_ip_address(self):
"""
Get DUT's ip address.
"""
return self.crb['IP']
def get_password(self):
"""
Get DUT's login password.
"""
return self.crb['pass']
def get_username(self):
"""
Get DUT's login username.
"""
return self.crb['user']
def dut_prerequisites(self):
print("******************** MyDut class file prerequisites call here")
"""
Prerequest function should be called before execute any test case.
Will call function to scan all lcore's information which on DUT.
Then call pci scan function to collect nic device information.
At last setup DUT' environment for validation.
"""
self.send_expect("cd %s" % self.base_dir, "# ")
self.send_expect("alias ls='ls --color=none'", "#")
if self.get_os_type() == 'freebsd':
self.send_expect('alias make=gmake', '# ')
self.init_core_list()
self.pci_devices_information()
# scan ports before restore interface
self.scan_ports()
# load port infor from config file
self.load_portconf()
self.mount_procfs()
# auto detect network topology
self.map_available_ports()
# print latest ports_info
for port_info in self.ports_info:
self.logger.info(port_info)
#self.ports_map = [0,1] #changes made here
if self.ports_map is None or len(self.ports_map) == 0:
self.logger.warning(
"ports_map should not be empty, please check all links")
# initialize virtualization resource pool
#self.virt_pool = VirtResource(self)
def stop_ports(self):
"""
After all execution done, some special nic like fm10k should be stop
"""
pass
def setup_memory(self, hugepages=-1):
"""
Setup hugepage on DUT.
"""
pass
def setup_memory_linux(self, hugepages=-1):
"""
Setup Linux hugepages.
"""
pass
def taskset(self, core):
if self.get_os_type() != 'linux':
return ''
return 'taskset %s ' % core
def is_ssh_session_port(self, pci_bus):
"""
Check if the pci device is the dut SSH session port.
"""
return
def get_dpdk_bind_script(self):
op = self.send_expect("ls", "#")
if "usertools" in op:
res = 'usertools/dpdk-devbind.py'
else:
op = self.send_expect("ls tools", "#")
if "dpdk_nic_bind.py" in op:
res = 'tools/dpdk_nic_bind.py'
else:
res = 'tools/dpdk-devbind.py'
return res
def bind_interfaces_linux(self, driver='igb_uio', nics_to_bind=None):
"""
Bind the interfaces to the selected driver. nics_to_bind can be None
to bind all interfaces or an array with the port indexes
"""
binding_list = '--bind=%s ' % driver
current_nic = 0
for (pci_bus, pci_id) in self.pci_devices_info:
if settings.accepted_nic(pci_id):
if self.is_ssh_session_port(pci_bus):
continue
if nics_to_bind is None or current_nic in nics_to_bind:
binding_list += '%s ' % (pci_bus)
current_nic += 1
if current_nic == 0:
self.logger.info("Not nic need bind driver: %s" % driver)
return
bind_script_path = self.get_dpdk_bind_script()
self.send_expect('%s --force %s' % (bind_script_path, binding_list),
'# ')
def unbind_interfaces_linux(self, nics_to_bind=None):
"""
Unbind the interfaces.
"""
binding_list = '-u '
current_nic = 0
for (pci_bus, pci_id) in self.pci_devices_info:
if settings.accepted_nic(pci_id):
if self.is_ssh_session_port(pci_bus):
continue
if nics_to_bind is None or current_nic in nics_to_bind:
binding_list += '%s ' % (pci_bus)
current_nic += 1
if current_nic == 0:
self.logger.info("Not nic need unbind driver")
return
bind_script_path = self.get_dpdk_bind_script()
self.send_expect('%s --force %s' % (bind_script_path, binding_list),
'# ')
def get_ports(self, nic_type='dpaa2', perf=None, socket=None):
"""
Return DUT port list with the filter of NIC type, whether run IXIA
performance test, whether request specified socket.
"""
ports = []
candidates = []
nictypes = []
if nic_type == 'any':
for portid in range(len(self.ports_info)):
ports.append(portid)
return ports
elif nic_type == 'dpaa2':
for portid in range(len(self.ports_info)):
if self.ports_info[portid]['source'] == 'dpaa2':
if (socket is None or self.ports_info[portid]['numa'] == -1
or socket == self.ports_info[portid]['numa']):
ports.append(portid)
ports = [0, 1]
return ports
elif nic_type == 'cfg':
for portid in range(len(self.ports_info)):
if self.ports_info[portid]['source'] == 'cfg':
if (socket is None or self.ports_info[portid]['numa'] == -1
or socket == self.ports_info[portid]['numa']):
ports.append(portid)
#ports = [0,1]
return ports
else:
self.logger.info("ports not found")
return
def get_ports_performance(self,
nic_type='any',
perf=None,
socket=None,
force_same_socket=True,
force_different_nic=True):
"""
Return the maximum available number of ports meeting the parameters.
Focuses on getting ports with same/different NUMA node and/or
same/different NIC.
"""
nic_type = "dpaa2"
biggest_set = [0, 1]
return biggest_set
def get_peer_pci(self, port_num):
"""
return the peer pci address of dut port
"""
if 'peer' not in self.ports_info[port_num]:
return None
else:
return self.ports_info[port_num]['peer']
def get_mac_address(self, port_num):
"""
return the port mac on dut
"""
return self.ports_info[port_num]['mac']
def get_ipv6_address(self, port_num):
"""
return the IPv6 address on dut
"""
return
def get_numa_id(self, port_num):
"""
return the Numa Id of port
"""
return 0
def lcore_table_print(self, horizontal=False):
if not horizontal:
result_table = ResultTable(['Socket', 'Core', 'Thread'])
for lcore in self.cores:
result_table.add_row(
[lcore['socket'], lcore['core'], lcore['thread']])
result_table.table_print()
else:
result_table = ResultTable(['X'] + [''] * len(self.cores))
result_table.add_row(['Thread'] +
[n['thread'] for n in self.cores])
result_table.add_row(['Core'] + [n['core'] for n in self.cores])
result_table.add_row(['Socket'] +
[n['socket'] for n in self.cores])
result_table.table_print()
def get_memory_channels(self):
n = self.crb['memory channels']
if n is not None and n > 0:
return n
else:
return 1
def check_ports_available(self, pci_bus, pci_id):
"""
Check that whether auto scanned ports ready to use
"""
pci_addr = "%s:%s" % (pci_bus, pci_id)
if self.nic_type == 'any':
return True
elif self.nic_type == 'cfg':
if self.conf.check_port_available(pci_bus) is True:
return True
elif self.nic_type == 'dpaa2':
if self.conf.check_port_available(pci_bus) is True:
return True
elif self.nic_type not in NICS.keys():
self.logger.warning("NOT SUPPORTED NIC TYPE: %s" % self.nic_type)
else:
codename = NICS[self.nic_type]
if pci_id == codename:
return True
return False
def load_serializer_ports(self):
cached_ports_info = self.serializer.load(self.PORT_INFO_CACHE_KEY)
if cached_ports_info is None:
return None
self.ports_info = cached_ports_info
def save_serializer_ports(self):
cached_ports_info = []
for port in self.ports_info:
port_info = {}
for key in port.keys():
if type(port[key]) is str:
port_info[key] = port[key]
cached_ports_info.append(port_info)
self.serializer.save(self.PORT_INFO_CACHE_KEY, cached_ports_info)
def scan_ports(self):
"""
Scan ports information or just read it from cache file.
"""
if self.read_cache:
self.load_serializer_ports()
self.scan_ports_cached()
if not self.read_cache or self.ports_info is None:
self.scan_ports_uncached()
def scan_ports_cached(self):
"""
Scan cached ports, instantiate tester port
"""
scan_ports_cached = getattr(
self, 'scan_ports_cached_%s' % self.get_os_type())
return scan_ports_cached()
def scan_ports_cached_linux(self):
"""
Scan Linux ports and instantiate tester port
"""
if self.ports_info is None:
return
for port_info in self.ports_info:
addr_array = port_info['pci'].split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
port_info['port'] = port
self.logger.info(
"DUT cached: [%s %s] %s" %
(port_info['pci'], port_info['type'], port_info['intf']))
def scan_ports_uncached(self):
"""
Scan ports and collect port's pci id, mac address, ipv6 address.
"""
scan_ports_uncached = getattr(
self, 'scan_ports_uncached_%s' % self.get_os_type())
return scan_ports_uncached()
def scan_ports_uncached_linux(self):
"""
Scan Linux ports and collect port's pci id, mac address, ipv6 address.
"""
self.ports_info = []
skipped = RED('Skipped: Unknown/not selected')
unknow_interface = RED('Skipped: unknow_interface')
domain_id = "0000"
bus_id = "01"
devfun_id = "00.0"
port = GetNicObj(self, domain_id, bus_id, devfun_id)
port.socket = 0 # set to 0 as numa node in ls2088 is returning -1
self.ports_info = [{
'intf': 'eth0',
'source': 'dpaa2',
'mac': 'b2:c8:30:9e:a6:0b',
'pci': 'nxp_NA',
'numa': 1,
'peer': '0001:00:00.0',
'type': 'nxp:NA',
'port': port
}, {
'intf': 'eth1',
'source': 'dpaa2',
'mac': 'b2:c8:30:9e:a6:0c',
'pci': 'nxp_NA',
'numa': 1,
'peer': '0001:01:00.0',
'type': 'nxp:NA',
'port': port
}]
for (pci_bus, pci_id) in self.pci_devices_info:
if self.check_ports_available(pci_bus, pci_id) is False:
self.logger.info("DUT: [%s %s] %s" %
(pci_bus, pci_id, skipped))
continue
addr_array = pci_bus.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
intf = port.get_interface_name()
if "No such file" in intf:
self.logger.info("DUT: [%s] %s" % (pci_bus, unknow_interface))
continue
macaddr = port.get_mac_addr()
if "No such file" in intf:
self.logger.info("DUT: [%s] %s" % (pci_bus, unknow_interface))
continue
numa = port.socket
# store the port info to port mapping
self.ports_info.append({
'port': port,
'pci': pci_bus,
'type': pci_id,
'numa': numa,
'intf': intf,
'mac': macaddr
})
if not port.get_interface2_name():
continue
intf = port.get_interface2_name()
macaddr = port.get_intf2_mac_addr()
numa = port.socket
# store the port info to port mapping
self.ports_info.append({
'port': port,
'pci': pci_bus,
'type': pci_id,
'numa': numa,
'intf': intf,
'mac': macaddr
})
def generate_sriov_vfs_by_port(self, port_id, vf_num, driver='default'):
"""
Generate SRIOV VFs with default driver it is bound now or specified driver.
"""
pass
def destroy_sriov_vfs_by_port(self, port_id):
pass
def destroy_all_sriov_vfs(self):
pass
def get_vm_core_list(self):
return
def get_core_list(self, config, socket=-1):
"""
Get lcore array according to the core config like "all", "1S/1C/1T".
We can specify the physical CPU socket by the "socket" parameter.
"""
return ["1", "2", "3", "4", "5", "6", "7"]
def load_portconf(self):
"""
Load port configurations for ports_info. If manually configured infor
not same as auto scanned, still use infor in configuration file.
"""
for port in self.ports_info:
pci_bus = port['pci']
ports_cfg = self.conf.get_ports_config()
if pci_bus in ports_cfg:
port_cfg = ports_cfg[pci_bus]
port_cfg['source'] = 'cfg'
else:
port_cfg = {}
for key in ['intf', 'mac', 'peer', 'source']:
if key in port_cfg:
if key in port and port_cfg[key].lower(
) != port[key].lower():
self.logger.warning(
"CONFIGURED %s NOT SAME AS SCANNED!!!" %
(key.upper()))
port[key] = port_cfg[key].lower()
if 'numa' in port_cfg:
if port_cfg['numa'] != port['numa']:
self.logger.warning(
"CONFIGURED NUMA NOT SAME AS SCANNED!!!")
port['numa'] = port_cfg['numa']
def map_available_ports(self):
"""
Load or generate network connection mapping list.
"""
if self.read_cache:
self.ports_map = self.serializer.load(self.PORT_MAP_CACHE_KEY)
if not self.read_cache or self.ports_map is None:
#self.map_available_ports_uncached()
self.serializer.save(self.PORT_MAP_CACHE_KEY, self.ports_map)
self.ports_map = [2, 1] #changes made for l2fwd
self.logger.warning("DUT PORT MAP: " + str(self.ports_map))
def map_available_ports_uncached(self):
"""
Generate network connection mapping list.
"""
pass
def check_port_occupied(self, port):
out = self.alt_session.send_expect('lsof -i:%d' % port, '# ')
if out == '':
return False
else:
return True
def virt_exit(self):
pass
def crb_exit(self):
"""
Recover all resource before crb exit
"""
out = self.send_expect("restool dprc list", "#")
if "dprc.2" in out:
pass
self.logger.logger_exit()
self.close()
class Dut(Crb):
"""
A connection to the CRB under test.
This class sends commands to the CRB and validates the responses. It is
implemented using either ssh for linuxapp or the terminal server for
baremetal.
All operations are in fact delegated to an instance of either CRBLinuxApp
or CRBBareMetal.
"""
PORT_MAP_CACHE_KEY = 'dut_port_map'
PORT_INFO_CACHE_KEY = 'dut_port_info'
NUMBER_CORES_CACHE_KEY = 'dut_number_cores'
CORE_LIST_CACHE_KEY = 'dut_core_list'
PCI_DEV_CACHE_KEY = 'dut_pci_dev_info'
def __init__(self, crb, serializer):
self.NAME = 'dut' + LOG_NAME_SEP + '%s' % crb['My IP']
super(Dut, self).__init__(crb, serializer, self.NAME)
self.host_init_flag = False
self.number_of_cores = 0
self.tester = None
self.cores = []
self.architecture = None
self.ports_info = []
self.conf = PortConf()
self.ports_map = []
self.virt_pool = None
# hypervisor pid list, used for cleanup
self.virt_pids = []
def init_host_session(self):
if self.host_init_flag:
pass
else:
self.host_session = SSHConnection(self.get_ip_address(),
self.NAME + '_host',
self.get_username(),
self.get_password())
self.host_session.init_log(self.logger)
self.host_init_flag = True
def new_session(self, suite=""):
"""
Create new session for dut instance. Session name will be unique.
"""
session_name = self.NAME + '_' + str(uuid4())
session = self.create_session(name=session_name)
if suite != "":
session.logger.config_suite(suite, self.NAME)
else:
session.logger.config_execution(self.NAME)
session.send_expect("cd %s" % self.base_dir, "# ")
return session
def close_session(self, session):
"""
close new session in dut instance
"""
self.destroy_session(session)
def change_config_option(self, target, parameter, value):
"""
This function change option in the config file
"""
self.send_expect(
"sed -i 's/%s=.*$/%s=%s/' config/defconfig_%s" %
(parameter, parameter, value, target), "# ")
def set_nic_type(self, nic_type):
"""
Set CRB NICS ready to validated.
"""
self.nic_type = nic_type
if 'cfg' in nic_type:
self.conf.load_ports_config(self.get_ip_address())
def set_toolchain(self, target):
"""
This looks at the current target and instantiates an attribute to
be either a CRBLinuxApp or CRBBareMetal object. These latter two
classes are private and should not be used directly by client code.
"""
self.kill_all()
self.target = target
[arch, _, _, toolchain] = target.split('-')
if toolchain == "icc":
icc_vars = os.getenv('ICC_VARS',
"/opt/intel/composer_xe_2013/bin/")
icc_vars += "compilervars.sh"
if arch == "x86_64":
icc_arch = "intel64"
elif arch == "i686":
icc_arch = "ia32"
self.send_expect("source " + icc_vars + " " + icc_arch, "# ")
self.architecture = arch
def mount_procfs(self):
"""
Mount proc file system.
"""
mount_procfs = getattr(self, 'mount_procfs_%s' % self.get_os_type())
mount_procfs()
def mount_procfs_linux(self):
pass
def mount_procfs_freebsd(self):
"""
Mount proc file system in Freebsd.
"""
self.send_expect('mount -t procfs proc /proc', '# ')
def get_ip_address(self):
"""
Get DUT's ip address.
"""
return self.crb['IP']
def get_password(self):
"""
Get DUT's login password.
"""
return self.crb['pass']
def get_username(self):
"""
Get DUT's login username.
"""
return self.crb['user']
def dut_prerequisites(self):
"""
Prerequest function should be called before execute any test case.
Will call function to scan all lcore's information which on DUT.
Then call pci scan function to collect nic device information.
At last setup DUT' environment for validation.
"""
self.send_expect("cd %s" % self.base_dir, "# ")
self.send_expect("alias ls='ls --color=none'", "#")
if self.get_os_type() == 'freebsd':
self.send_expect('alias make=gmake', '# ')
self.init_core_list()
self.pci_devices_information()
# make sure ipv6 enable before scan
self.enable_tester_ipv6()
# scan ports before restore interface
self.scan_ports()
# restore dut ports to kernel
self.restore_interfaces()
# rescan ports after interface up
self.rescan_ports()
# load port infor from config file
self.load_portconf()
self.mount_procfs()
# auto detect network topology
self.map_available_ports()
# disable tester port ipv6
self.disable_tester_ipv6()
# print latest ports_info
for port_info in self.ports_info:
self.logger.info(port_info)
if self.ports_map is None or len(self.ports_map) == 0:
self.logger.warning(
"ports_map should not be empty, please check all links")
# initialize virtualization resource pool
self.virt_pool = VirtResource(self)
def restore_interfaces(self):
"""
Restore all ports's interfaces.
"""
# no need to restore for all info has been recorded
if self.read_cache:
return
restore_interfaces = getattr(
self, 'restore_interfaces_%s' % self.get_os_type())
return restore_interfaces()
def restore_interfaces_freebsd(self):
"""
Restore FreeBSD interfaces.
"""
self.send_expect("kldunload nic_uio.ko", "#")
self.send_expect("kldunload contigmem.ko", "#")
self.send_expect("kldload if_ixgbe.ko", "#", 20)
def stop_ports(self):
"""
After all execution done, some special nic like fm10k should be stop
"""
for (pci_bus, pci_id) in self.pci_devices_info:
driver = settings.get_nic_driver(pci_id)
if driver is not None:
# unbind device driver
addr_array = pci_bus.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
port.stop()
def restore_interfaces_linux(self):
"""
Restore Linux interfaces.
"""
for port in self.ports_info:
pci_bus = port['pci']
pci_id = port['type']
# get device driver
driver = settings.get_nic_driver(pci_id)
if driver is not None:
# unbind device driver
addr_array = pci_bus.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
self.send_expect(
'echo %s > /sys/bus/pci/devices/%s\:%s\:%s/driver/unbind' %
(pci_bus, domain_id, bus_id, devfun_id), '# ')
# bind to linux kernel driver
self.send_expect('modprobe %s' % driver, '# ')
self.send_expect(
'echo %s > /sys/bus/pci/drivers/%s/bind' %
(pci_bus, driver), '# ')
itf = port.get_interface_name()
self.send_expect("ifconfig %s up" % itf, "# ")
else:
self.logger.info("NOT FOUND DRIVER FOR PORT (%s|%s)!!!" %
(pci_bus, pci_id))
def setup_memory(self, hugepages=-1):
"""
Setup hugepage on DUT.
"""
try:
function_name = 'setup_memory_%s' % self.get_os_type()
setup_memory = getattr(self, function_name)
setup_memory(hugepages)
except AttributeError:
self.logger.error("%s is not implemented" % function_name)
def setup_memory_linux(self, hugepages=-1):
"""
Setup Linux hugepages.
"""
if self.virttype == 'XEN':
return
hugepages_size = self.send_expect(
"awk '/Hugepagesize/ {print $2}' /proc/meminfo", "# ")
total_huge_pages = self.get_total_huge_pages()
force_socket = False
if int(hugepages_size) < (1024 * 1024):
if self.architecture == "x86_64":
arch_huge_pages = hugepages if hugepages > 0 else 4096
elif self.architecture == "i686":
arch_huge_pages = hugepages if hugepages > 0 else 512
force_socket = True
# set huge pagesize for x86_x32 abi target
elif self.architecture == "x86_x32":
arch_huge_pages = hugepages if hugepages > 0 else 256
force_socket = True
elif self.architecture == "ppc_64":
arch_huge_pages = hugepages if hugepages > 0 else 512
elif self.architecture == "arm64":
if hugepages_size == "524288":
arch_huge_pages = hugepages if hugepages > 0 else 8
else:
arch_huge_pages = hugepages if hugepages > 0 else 2048
if total_huge_pages != arch_huge_pages:
# before all hugepage average distribution by all socket,
# but sometimes create mbuf pool on socket 0 failed when setup testpmd,
# so set all huge page on socket 0
if force_socket:
self.set_huge_pages(arch_huge_pages, 0)
else:
self.set_huge_pages(arch_huge_pages)
self.mount_huge_pages()
self.hugepage_path = self.strip_hugepage_path()
def setup_memory_freebsd(self, hugepages=-1):
"""
Setup Freebsd hugepages.
"""
if hugepages is -1:
hugepages = 4096
num_buffers = hugepages / 1024
if num_buffers:
self.send_expect('kenv hw.contigmem.num_buffers=%d' % num_buffers,
"#")
self.send_expect("kldunload contigmem.ko", "#")
self.send_expect("kldload ./%s/kmod/contigmem.ko" % self.target, "#")
def taskset(self, core):
if self.get_os_type() != 'linux':
return ''
return 'taskset %s ' % core
def is_ssh_session_port(self, pci_bus):
"""
Check if the pci device is the dut SSH session port.
"""
port = None
for port_info in self.ports_info:
if pci_bus == port_info['pci']:
port = port_info['port']
break
if port and port.get_ipv4_addr() == crbs['IP'].strip():
return True
else:
return False
def get_dpdk_bind_script(self):
op = self.send_command("ls")
if "usertools" in op:
res = 'usertools/dpdk-devbind.py'
else:
op = self.send_command("ls tools")
if "dpdk_nic_bind.py" in op:
res = 'tools/dpdk_nic_bind.py'
else:
res = 'tools/dpdk-devbind.py'
return res
def bind_interfaces_linux(self, driver='igb_uio', nics_to_bind=None):
"""
Bind the interfaces to the selected driver. nics_to_bind can be None
to bind all interfaces or an array with the port indexes
"""
binding_list = '--bind=%s ' % driver
current_nic = 0
for (pci_bus, pci_id) in self.pci_devices_info:
if settings.accepted_nic(pci_id):
if self.is_ssh_session_port(pci_bus):
continue
if nics_to_bind is None or current_nic in nics_to_bind:
binding_list += '%s ' % (pci_bus)
current_nic += 1
if current_nic == 0:
self.logger.info("Not nic need bind driver: %s" % driver)
return
bind_script_path = self.get_dpdk_bind_script()
self.send_expect('%s --force %s' % (bind_script_path, binding_list),
'# ')
def unbind_interfaces_linux(self, nics_to_bind=None):
"""
Unbind the interfaces.
"""
binding_list = '-u '
current_nic = 0
for (pci_bus, pci_id) in self.pci_devices_info:
if settings.accepted_nic(pci_id):
if self.is_ssh_session_port(pci_bus):
continue
if nics_to_bind is None or current_nic in nics_to_bind:
binding_list += '%s ' % (pci_bus)
current_nic += 1
if current_nic == 0:
self.logger.info("Not nic need unbind driver")
return
bind_script_path = self.get_dpdk_bind_script()
self.send_expect('%s --force %s' % (bind_script_path, binding_list),
'# ')
def get_ports(self, nic_type='any', perf=None, socket=None):
"""
Return DUT port list with the filter of NIC type, whether run IXIA
performance test, whether request specified socket.
"""
ports = []
candidates = []
nictypes = []
if nic_type == 'any':
for portid in range(len(self.ports_info)):
ports.append(portid)
return ports
elif nic_type == 'cfg':
for portid in range(len(self.ports_info)):
if self.ports_info[portid]['source'] == 'cfg':
if (socket is None or self.ports_info[portid]['numa'] == -1
or socket == self.ports_info[portid]['numa']):
ports.append(portid)
return ports
else:
for portid in range(len(self.ports_info)):
port_info = self.ports_info[portid]
# match nic type
if port_info['type'] == NICS[nic_type]:
# match numa or none numa awareness
if (socket is None or port_info['numa'] == -1
or socket == port_info['numa']):
# port has link,
if self.tester.get_local_port(portid) != -1:
ports.append(portid)
return ports
def get_ports_performance(self,
nic_type='any',
perf=None,
socket=None,
force_same_socket=True,
force_different_nic=True):
"""
Return the maximum available number of ports meeting the parameters.
Focuses on getting ports with same/different NUMA node and/or
same/different NIC.
"""
available_ports = self.get_ports(nic_type, perf, socket)
accepted_sets = []
while len(available_ports) > 0:
accepted_ports = []
# first avaiable port is the reference port
accepted_ports.append(available_ports[0])
# check from second port according to parameter
for port in available_ports[1:]:
if force_same_socket and socket is None:
if self.ports_info[port]['numa'] != self.ports_info[
accepted_ports[0]]['numa']:
continue
if force_different_nic:
if self.ports_info[port]['pci'][:-1] == self.ports_info[
accepted_ports[0]]['pci'][:-1]:
continue
accepted_ports.append(port)
for port in accepted_ports:
available_ports.remove(port)
accepted_sets.append(accepted_ports)
biggest_set = max(accepted_sets, key=lambda s: len(s))
return biggest_set
def get_peer_pci(self, port_num):
"""
return the peer pci address of dut port
"""
if 'peer' not in self.ports_info[port_num]:
return None
else:
return self.ports_info[port_num]['peer']
def get_mac_address(self, port_num):
"""
return the port mac on dut
"""
return self.ports_info[port_num]['mac']
def get_ipv6_address(self, port_num):
"""
return the IPv6 address on dut
"""
return self.ports_info[port_num]['ipv6']
def get_numa_id(self, port_num):
"""
return the Numa Id of port
"""
if self.ports_info[port_num]['numa'] == -1:
self.logger.warning('NUMA not supported')
return self.ports_info[port_num]['numa']
def lcore_table_print(self, horizontal=False):
if not horizontal:
result_table = ResultTable(['Socket', 'Core', 'Thread'])
for lcore in self.cores:
result_table.add_row(
[lcore['socket'], lcore['core'], lcore['thread']])
result_table.table_print()
else:
result_table = ResultTable(['X'] + [''] * len(self.cores))
result_table.add_row(['Thread'] +
[n['thread'] for n in self.cores])
result_table.add_row(['Core'] + [n['core'] for n in self.cores])
result_table.add_row(['Socket'] +
[n['socket'] for n in self.cores])
result_table.table_print()
def get_memory_channels(self):
n = self.crb['memory channels']
if n is not None and n > 0:
return n
else:
return 1
def check_ports_available(self, pci_bus, pci_id):
"""
Check that whether auto scanned ports ready to use
"""
pci_addr = "%s:%s" % (pci_bus, pci_id)
if self.nic_type == 'any':
return True
elif self.nic_type == 'cfg':
if self.conf.check_port_available(pci_bus) is True:
return True
elif self.nic_type not in NICS.keys():
self.logger.warning("NOT SUPPORTED NIC TYPE: %s" % self.nic_type)
else:
codename = NICS[self.nic_type]
if pci_id == codename:
return True
return False
def rescan_ports(self):
"""
Rescan ports information
"""
if self.read_cache:
return
if self.ports_info:
self.rescan_ports_uncached()
self.save_serializer_ports()
def rescan_ports_uncached(self):
"""
rescan ports and update port's mac adress, intf, ipv6 address.
"""
rescan_ports_uncached = getattr(
self, 'rescan_ports_uncached_%s' % self.get_os_type())
return rescan_ports_uncached()
def rescan_ports_uncached_linux(self):
unknow_interface = RED('Skipped: unknow_interface')
for port_info in self.ports_info:
port = port_info['port']
intf = port.get_interface_name()
port_info['intf'] = intf
out = self.send_expect("ip link show %s" % intf, "# ")
if "DOWN" in out:
self.send_expect("ip link set %s up" % intf, "# ")
time.sleep(5)
port_info['mac'] = port.get_mac_addr()
out = self.send_expect(
"ip -family inet6 address show dev %s | awk '/inet6/ { print $2 }'"
% intf, "# ")
ipv6 = out.split('/')[0]
# Unconnected ports don't have IPv6
if ":" not in ipv6:
ipv6 = "Not connected"
out = self.send_expect(
"ip -family inet address show dev %s | awk '/inet/ { print $2 }'"
% intf, "# ")
ipv4 = out.split('/')[0]
port_info['ipv6'] = ipv6
port_info['ipv4'] = ipv4
def rescan_ports_uncached_freebsd(self):
unknow_interface = RED('Skipped: unknow_interface')
for port_info in self.ports_info:
port = port_info['port']
intf = port.get_interface_name()
if "No such file" in intf:
self.logger.info("DUT: [%s] %s" % (pci_bus, unknow_interface))
continue
self.send_expect("ifconfig %s up" % intf, "# ")
time.sleep(5)
macaddr = port.get_mac_addr()
ipv6 = port.get_ipv6_addr()
# Unconnected ports don't have IPv6
if ipv6 is None:
ipv6 = "Not connected"
port_info['mac'] = macaddr
port_info['intf'] = intf
port_info['ipv6'] = ipv6
def load_serializer_ports(self):
cached_ports_info = self.serializer.load(self.PORT_INFO_CACHE_KEY)
if cached_ports_info is None:
return None
self.ports_info = cached_ports_info
def save_serializer_ports(self):
cached_ports_info = []
for port in self.ports_info:
port_info = {}
for key in port.keys():
if type(port[key]) is str:
port_info[key] = port[key]
cached_ports_info.append(port_info)
self.serializer.save(self.PORT_INFO_CACHE_KEY, cached_ports_info)
def scan_ports(self):
"""
Scan ports information or just read it from cache file.
"""
if self.read_cache:
self.load_serializer_ports()
self.scan_ports_cached()
if not self.read_cache or self.ports_info is None:
self.scan_ports_uncached()
def scan_ports_cached(self):
"""
Scan cached ports, instantiate tester port
"""
scan_ports_cached = getattr(
self, 'scan_ports_cached_%s' % self.get_os_type())
return scan_ports_cached()
def scan_ports_cached_linux(self):
"""
Scan Linux ports and instantiate tester port
"""
if self.ports_info is None:
return
for port_info in self.ports_info:
addr_array = port_info['pci'].split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
port_info['port'] = port
self.logger.info(
"DUT cached: [%s %s] %s" %
(port_info['pci'], port_info['type'], port_info['intf']))
def scan_ports_uncached(self):
"""
Scan ports and collect port's pci id, mac adress, ipv6 address.
"""
scan_ports_uncached = getattr(
self, 'scan_ports_uncached_%s' % self.get_os_type())
return scan_ports_uncached()
def scan_ports_uncached_linux(self):
"""
Scan Linux ports and collect port's pci id, mac adress, ipv6 address.
"""
self.ports_info = []
skipped = RED('Skipped: Unknown/not selected')
unknow_interface = RED('Skipped: unknow_interface')
for (pci_bus, pci_id) in self.pci_devices_info:
if self.check_ports_available(pci_bus, pci_id) is False:
self.logger.info("DUT: [%s %s] %s" %
(pci_bus, pci_id, skipped))
continue
addr_array = pci_bus.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
intf = port.get_interface_name()
if "No such file" in intf:
self.logger.info("DUT: [%s] %s" % (pci_bus, unknow_interface))
continue
macaddr = port.get_mac_addr()
if "No such file" in intf:
self.logger.info("DUT: [%s] %s" % (pci_bus, unknow_interface))
continue
numa = port.socket
# store the port info to port mapping
self.ports_info.append({
'port': port,
'pci': pci_bus,
'type': pci_id,
'numa': numa,
'intf': intf,
'mac': macaddr
})
if not port.get_interface2_name():
continue
intf = port.get_interface2_name()
macaddr = port.get_intf2_mac_addr()
numa = port.socket
# store the port info to port mapping
self.ports_info.append({
'port': port,
'pci': pci_bus,
'type': pci_id,
'numa': numa,
'intf': intf,
'mac': macaddr
})
def scan_ports_uncached_freebsd(self):
"""
Scan Freebsd ports and collect port's pci id, mac adress, ipv6 address.
"""
self.ports_info = []
skipped = RED('Skipped: Unknown/not selected')
for (pci_bus, pci_id) in self.pci_devices_info:
if not settings.accepted_nic(pci_id):
self.logger.info("DUT: [%s %s] %s" %
(pci_bus, pci_id, skipped))
continue
addr_array = pci_bus.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
intf = port.get_interface_name()
macaddr = port.get_mac_addr()
ipv6 = port.get_ipv6_addr()
if ipv6 is None:
ipv6 = "Not available"
self.logger.warning("NUMA not available on FreeBSD")
self.logger.info("DUT: [%s %s] %s %s" %
(pci_bus, pci_id, intf, ipv6))
# convert bsd format to linux format
pci_split = pci_bus.split(':')
pci_bus_id = hex(int(pci_split[0]))[2:]
if len(pci_split[1]) == 1:
pci_dev_str = "0" + pci_split[1]
else:
pci_dev_str = pci_split[1]
pci_str = "%s:%s.%s" % (pci_bus_id, pci_dev_str, pci_split[2])
# store the port info to port mapping
self.ports_info.append({
'port': port,
'pci': pci_str,
'type': pci_id,
'intf': intf,
'mac': macaddr,
'ipv6': ipv6,
'numa': -1
})
def generate_sriov_vfs_by_port(self, port_id, vf_num, driver='default'):
"""
Generate SRIOV VFs with default driver it is bound now or specifid driver.
"""
port = self.ports_info[port_id]['port']
port_driver = port.get_nic_driver()
if driver == 'default':
if not port_driver:
self.logger.info(
"No driver on specified port, can not generate SRIOV VF.")
return None
else:
if port_driver != driver:
port.bind_driver(driver)
port.generate_sriov_vfs(vf_num)
# append the VF PCIs into the ports_info
sriov_vfs_pci = port.get_sriov_vfs_pci()
self.ports_info[port_id]['sriov_vfs_pci'] = sriov_vfs_pci
# instantiate the VF
vfs_port = []
for vf_pci in sriov_vfs_pci:
addr_array = vf_pci.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
vf_port = GetNicObj(self, domain_id, bus_id, devfun_id)
vfs_port.append(vf_port)
self.ports_info[port_id]['vfs_port'] = vfs_port
pci = self.ports_info[port_id]['pci']
self.virt_pool.add_vf_on_pf(pf_pci=pci, vflist=sriov_vfs_pci)
def destroy_sriov_vfs_by_port(self, port_id):
port = self.ports_info[port_id]['port']
vflist = []
port_driver = port.get_nic_driver()
if 'sriov_vfs_pci' in self.ports_info[port_id] and \
self.ports_info[port_id]['sriov_vfs_pci']:
vflist = self.ports_info[port_id]['sriov_vfs_pci']
else:
if not port.get_sriov_vfs_pci():
return
if not port_driver:
self.logger.info(
"No driver on specified port, skip destroy SRIOV VF.")
else:
sriov_vfs_pci = port.destroy_sriov_vfs()
self.ports_info[port_id]['sriov_vfs_pci'] = []
self.ports_info[port_id]['vfs_port'] = []
pci = self.ports_info[port_id]['pci']
self.virt_pool.del_vf_on_pf(pf_pci=pci, vflist=vflist)
def destroy_all_sriov_vfs(self):
if self.ports_info == None:
return
for port_id in range(len(self.ports_info)):
self.destroy_sriov_vfs_by_port(port_id)
def get_vm_core_list(self):
return VMCORELIST[self.crb['VM CoreList']]
def load_portconf(self):
"""
Load port configurations for ports_info. If manually configured infor
not same as auto scanned, still use infor in configuration file.
"""
for port in self.ports_info:
pci_bus = port['pci']
ports_cfg = self.conf.get_ports_config()
if pci_bus in ports_cfg:
port_cfg = ports_cfg[pci_bus]
port_cfg['source'] = 'cfg'
else:
port_cfg = {}
for key in ['intf', 'mac', 'peer', 'source']:
if key in port_cfg:
if key in port and port_cfg[key].lower(
) != port[key].lower():
self.logger.warning(
"CONFIGURED %s NOT SAME AS SCANNED!!!" %
(key.upper()))
port[key] = port_cfg[key].lower()
if 'numa' in port_cfg:
if port_cfg['numa'] != port['numa']:
self.logger.warning(
"CONFIGURED NUMA NOT SAME AS SCANNED!!!")
port['numa'] = port_cfg['numa']
def map_available_ports(self):
"""
Load or generate network connection mapping list.
"""
if self.read_cache:
self.ports_map = self.serializer.load(self.PORT_MAP_CACHE_KEY)
if not self.read_cache or self.ports_map is None:
self.map_available_ports_uncached()
self.serializer.save(self.PORT_MAP_CACHE_KEY, self.ports_map)
self.logger.warning("DUT PORT MAP: " + str(self.ports_map))
def map_available_ports_uncached(self):
"""
Generate network connection mapping list.
"""
nrPorts = len(self.ports_info)
if nrPorts == 0:
return
remove = []
self.ports_map = [-1] * nrPorts
hits = [False] * len(self.tester.ports_info)
for dutPort in range(nrPorts):
peer = self.get_peer_pci(dutPort)
dutpci = self.ports_info[dutPort]['pci']
if peer is not None:
for remotePort in range(len(self.tester.ports_info)):
if self.tester.ports_info[remotePort]['pci'].lower(
) == peer.lower():
hits[remotePort] = True
self.ports_map[dutPort] = remotePort
break
if self.ports_map[dutPort] == -1:
self.logger.error("CONFIGURED TESTER PORT CANNOT FOUND!!!")
else:
continue # skip ping6 map
for remotePort in range(len(self.tester.ports_info)):
if hits[remotePort]:
continue
# skip ping self port
remotepci = self.tester.ports_info[remotePort]['pci']
if (self.crb['IP']
== self.crb['tester IP']) and (dutpci == remotepci):
continue
# skip ping those not connected port
ipv6 = self.get_ipv6_address(dutPort)
if ipv6 == "Not connected":
if self.tester.ports_info[remotePort].has_key('ipv4'):
out = self.tester.send_ping(
dutPort,
self.tester.ports_info[remotePort]['ipv4'],
self.get_mac_address(dutPort))
else:
continue
else:
if getattr(self, 'send_ping6', None):
out = self.send_ping6(
dutPort,
self.tester.ports_info[remotePort]['ipv6'],
self.get_mac_address(dutPort))
else:
out = self.tester.send_ping6(
remotePort, ipv6, self.get_mac_address(dutPort))
if ('64 bytes from' in out):
self.logger.info("PORT MAP: [dut %d: tester %d]" %
(dutPort, remotePort))
self.ports_map[dutPort] = remotePort
hits[remotePort] = True
if self.crb['IP'] == self.crb['tester IP']:
# remove dut port act as tester port
remove_port = self.get_port_info(remotepci)
if remove_port is not None:
remove.append(remove_port)
# skip ping from those port already act as dut port
testerPort = self.tester.get_local_index(dutpci)
if testerPort != -1:
hits[testerPort] = True
break
for port in remove:
self.ports_info.remove(port)
def disable_tester_ipv6(self):
for tester_port in self.ports_map:
if self.tester.ports_info[tester_port]['type'] != 'ixia':
port = self.tester.ports_info[tester_port]['port']
port.disable_ipv6()
def enable_tester_ipv6(self):
for tester_port in range(len(self.tester.ports_info)):
if self.tester.ports_info[tester_port]['type'] != 'ixia':
port = self.tester.ports_info[tester_port]['port']
port.enable_ipv6()
def check_port_occupied(self, port):
out = self.alt_session.send_expect('lsof -i:%d' % port, '# ')
if out == '':
return False
else:
return True
def get_maximal_vnc_num(self):
out = self.send_expect("ps aux | grep '\-vnc' | grep -v grep", '# ')
if out:
ports = re.findall(r'-vnc .*?:(\d+)', out)
for num in range(len(ports)):
ports[num] = int(ports[num])
ports.sort()
else:
ports = [
0,
]
return ports[-1]
def close(self):
"""
Close ssh session of DUT.
"""
if self.session:
self.session.close()
self.session = None
if self.alt_session:
self.alt_session.close()
self.alt_session = None
if self.host_init_flag:
self.host_session.close()
def virt_exit(self):
"""
Stop all unstopped hypervisors process
"""
# try to kill all hypervisor process
for pid in self.virt_pids:
self.send_expect("kill -s SIGTERM %d" % pid,
"# ",
alt_session=True)
time.sleep(3)
self.virt_pids = []
def crb_exit(self):
"""
Recover all resource before crb exit
"""
self.logger.logger_exit()
self.enable_tester_ipv6()
self.close()
class MyDut(Crb):
"""
A connection to the CRB under test.
This class sends commands to the CRB and validates the responses. It is
implemented using either ssh for linuxapp or the terminal server for
baremetal.
All operations are in fact delegated to an instance of either CRBLinuxApp
or CRBBareMetal.
"""
PORT_MAP_CACHE_KEY = 'dut_port_map'
PORT_INFO_CACHE_KEY = 'dut_port_info'
NUMBER_CORES_CACHE_KEY = 'dut_number_cores'
CORE_LIST_CACHE_KEY = 'dut_core_list'
PCI_DEV_CACHE_KEY = 'dut_pci_dev_info'
def __init__(self, crb, serializer, dut_id):
print("********** MyDut python file first line")
self.NAME = 'dut' + LOG_NAME_SEP + '%s' % crb['My IP']
super(MyDut, self).__init__(crb, serializer, self.NAME, alt_session=True, dut_id=dut_id)
self.host_init_flag = False
self.number_of_cores = 0 # changed here
self.tester = None
self.cores = []
self.architecture = None
self.ports_info = []
self.conf = PortConf()
self.ports_map = []
self.virt_pool = None
# hypervisor pid list, used for cleanup
self.virt_pids = []
self.socket =0 # changed here
def change_config_option(self, target, parameter, value):
"""
This function change option in the config file
"""
self.send_expect("sed -i 's/%s=.*$/%s=%s/' config/defconfig_%s" %
(parameter, parameter, value, target), "# ")
def set_nic_type(self, nic_type):
"""
Set CRB NICS ready to validated.
"""
self.nic_type = nic_type
if 'cfg' in nic_type:
self.conf.load_ports_config(self.get_ip_address())
def set_toolchain(self, target):
"""
This looks at the current target and instantiates an attribute to
be either a CRBLinuxApp or CRBBareMetal object. These latter two
classes are private and should not be used directly by client code.
"""
pass
def mount_procfs(self):
"""
Mount proc file system.
"""
mount_procfs = getattr(self, 'mount_procfs_%s' % self.get_os_type())
mount_procfs()
def mount_procfs_linux(self):
pass
def get_ip_address(self):
"""
Get DUT's ip address.
"""
return self.crb['IP']
def get_password(self):
"""
Get DUT's login password.
"""
return self.crb['pass']
def get_username(self):
"""
Get DUT's login username.
"""
return self.crb['user']
def prerequisites(self):
"""
Copy DPDK package to dut and apply patch files.
"""
if not self.skip_setup:
self.prepare_package()
self.ls_prerequisites()
self.stage = "post-init"
def dut_prerequisites(self):
"""
Prerequest function should be called before execute any test case.
Will call function to scan all lcore's information which on DUT.
Then call pci scan function to collect nic device information.
At last setup DUT' environment for validation.
"""
self.send_expect("cd %s" % self.base_dir, "# ")
self.send_expect("alias ls='ls --color=none'", "#")
if self.get_os_type() == 'freebsd':
self.send_expect('alias make=gmake', '# ')
self.init_core_list()
self.pci_devices_information()
# scan ports before restore interface
self.scan_ports()
# restore dut ports to kernel
self.restore_interfaces()
# rescan ports after interface up
#self.rescan_ports()
# load port infor from config file
self.load_portconf()
self.mount_procfs()
# auto detect network topology
self.map_available_ports()
# print latest ports_info
for port_info in self.ports_info:
self.logger.info(port_info)
self.ports_map = [0,1]
if self.ports_map is None or len(self.ports_map) == 0:
self.logger.warning("ports_map should not be empty, please check all links")
# initialize virtualization resource pool
#self.virt_pool = VirtResource(self)
def restore_interfaces(self): #no need
"""
Restore all ports's interfaces.
"""
# no need to restore for all info has been recorded
pass
def stop_ports(self):
"""
After all execution done, some special nic like fm10k should be stop
"""
for (pci_bus, pci_id) in self.pci_devices_info:
driver = settings.get_nic_driver(pci_id)
if driver is not None:
# unbind device driver
addr_array = pci_bus.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
port.stop()
def restore_interfaces_linux(self): #no need
"""
Restore Linux interfaces.
"""
pass
def setup_memory(self, hugepages=-1):
"""
Setup hugepage on DUT.
"""
pass
def setup_memory_linux(self, hugepages=-1):
"""
Setup Linux hugepages.
"""
pass
def taskset(self, core): #no need
pass
def is_ssh_session_port(self, pci_bus): #no need
"""
Check if the pci device is the dut SSH session port.
"""
pass
def get_dpdk_bind_script(self): #no need
pass
def bind_interfaces_linux(self, driver='igb_uio', nics_to_bind=None): #no need
"""
Bind the interfaces to the selected driver. nics_to_bind can be None
to bind all interfaces or an array with the port indexes
"""
pass
def unbind_interfaces_linux(self, nics_to_bind=None): #no need
"""
Unbind the interfaces.
"""
pass
def get_ports(self, nic_type='any', perf=None, socket=None):
"""
Return DUT port list with the filter of NIC type, whether run IXIA
performance test, whether request specified socket.
"""
ports = []
candidates = []
nictypes = []
if nic_type == 'any':
for portid in range(len(self.ports_info)):
ports.append(portid)
return ports
elif nic_type == 'cfg':
for portid in range(len(self.ports_info)):
if self.ports_info[portid]['source'] == 'cfg':
if (socket is None or
self.ports_info[portid]['numa'] == -1 or
socket == self.ports_info[portid]['numa']):
ports.append(portid)
return ports
else:
for portid in range(len(self.ports_info)):
port_info = self.ports_info[portid]
# match nic type
if port_info['type'] == NICS[nic_type]:
# match numa or none numa awareness
if (socket is None or
port_info['numa'] == -1 or
socket == port_info['numa']):
# port has link,
if self.tester.get_local_port(portid) != -1:
ports.append(portid)
return ports
def get_ports_performance(self, nic_type='any', perf=None, socket=None,
force_same_socket=True,
force_different_nic=True):
"""
Return the maximum available number of ports meeting the parameters.
Focuses on getting ports with same/different NUMA node and/or
same/different NIC.
"""
available_ports = self.get_ports(nic_type, perf, socket)
accepted_sets = []
while len(available_ports) > 0:
accepted_ports = []
# first available port is the reference port
accepted_ports.append(available_ports[0])
# check from second port according to parameter
for port in available_ports[1:]:
if force_same_socket and socket is None:
if self.ports_info[port]['numa'] != self.ports_info[accepted_ports[0]]['numa']:
continue
if force_different_nic:
if self.ports_info[port]['pci'][:-1] == self.ports_info[accepted_ports[0]]['pci'][:-1]:
continue
accepted_ports.append(port)
for port in accepted_ports:
available_ports.remove(port)
accepted_sets.append(accepted_ports)
biggest_set = max(accepted_sets, key=lambda s: len(s))
return biggest_set
def get_peer_pci(self, port_num): #no need
"""
return the peer pci address of dut port
"""
if 'peer' not in self.ports_info[port_num]:
return None
else:
return self.ports_info[port_num]['peer']
def get_mac_address(self, port_num):
"""
return the port mac on dut
"""
return self.ports_info[port_num]['mac']
def get_ipv6_address(self, port_num):
"""
return the IPv6 address on dut
"""
return self.ports_info[port_num]['ipv6']
def get_numa_id(self, port_num):
"""
return the Numa Id of port
"""
if self.ports_info[port_num]['numa'] == -1:
self.logger.warning('NUMA not supported')
return self.ports_info[port_num]['numa']
def lcore_table_print(self, horizontal=False): #no need
if not horizontal:
result_table = ResultTable(['Socket', 'Core', 'Thread'])
for lcore in self.cores:
result_table.add_row([lcore['socket'], lcore['core'], lcore['thread']])
result_table.table_print()
else:
result_table = ResultTable(['X'] + [''] * len(self.cores))
result_table.add_row(['Thread'] + [n['thread'] for n in self.cores])
result_table.add_row(['Core'] + [n['core'] for n in self.cores])
result_table.add_row(['Socket'] + [n['socket'] for n in self.cores])
result_table.table_print()
def get_memory_channels(self):
n = self.crb['memory channels']
if n is not None and n > 0:
return n
else:
return 1
def check_ports_available(self, pci_bus, pci_id): #no need
"""
Check that whether auto scanned ports ready to use
"""
pci_addr = "%s:%s" % (pci_bus, pci_id)
if self.nic_type == 'any':
return True
elif self.nic_type == 'cfg':
if self.conf.check_port_available(pci_bus) is True:
return True
elif self.nic_type not in NICS.keys():
self.logger.warning("NOT SUPPORTED NIC TYPE: %s" % self.nic_type)
else:
codename = NICS[self.nic_type]
if pci_id == codename:
return True
return False
def load_serializer_ports(self):
cached_ports_info = self.serializer.load(self.PORT_INFO_CACHE_KEY)
if cached_ports_info is None:
return None
self.ports_info = cached_ports_info
def save_serializer_ports(self):
cached_ports_info = []
for port in self.ports_info:
port_info = {}
for key in port.keys():
if type(port[key]) is str:
port_info[key] = port[key]
cached_ports_info.append(port_info)
self.serializer.save(self.PORT_INFO_CACHE_KEY, cached_ports_info)
def scan_ports(self):
"""
Scan ports information or just read it from cache file.
"""
if self.read_cache:
self.load_serializer_ports()
self.scan_ports_cached()
if not self.read_cache or self.ports_info is None:
self.scan_ports_uncached()
def scan_ports_cached(self):
"""
Scan cached ports, instantiate tester port
"""
scan_ports_cached = getattr(self, 'scan_ports_cached_%s' % self.get_os_type())
return scan_ports_cached()
def scan_ports_cached_linux(self):
"""
Scan Linux ports and instantiate tester port
"""
if self.ports_info is None:
return
for port_info in self.ports_info:
addr_array = port_info['pci'].split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
port_info['port'] = port
self.logger.info("DUT cached: [%s %s] %s" % (port_info['pci'],
port_info['type'], port_info['intf']))
def scan_ports_uncached(self):
"""
Scan ports and collect port's pci id, mac address, ipv6 address.
"""
scan_ports_uncached = getattr(self, 'scan_ports_uncached_%s' % self.get_os_type())
return scan_ports_uncached()
def scan_ports_uncached_linux(self):
"""
Scan Linux ports and collect port's pci id, mac address, ipv6 address.
"""
self.ports_info = []
skipped = RED('Skipped: Unknown/not selected')
unknow_interface = RED('Skipped: unknow_interface')
for (pci_bus, pci_id) in self.pci_devices_info:
if self.check_ports_available(pci_bus, pci_id) is False:
self.logger.info("DUT: [%s %s] %s" % (pci_bus, pci_id,
skipped))
continue
addr_array = pci_bus.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
intf = port.get_interface_name()
if "No such file" in intf:
self.logger.info("DUT: [%s] %s" % (pci_bus, unknow_interface))
continue
macaddr = port.get_mac_addr()
if "No such file" in intf:
self.logger.info("DUT: [%s] %s" % (pci_bus, unknow_interface))
continue
numa = port.socket
# store the port info to port mapping
self.ports_info.append(
{'port': port, 'pci': pci_bus, 'type': pci_id, 'numa': numa,
'intf': intf, 'mac': macaddr})
if not port.get_interface2_name():
continue
intf = port.get_interface2_name()
macaddr = port.get_intf2_mac_addr()
numa = port.socket
# store the port info to port mapping
self.ports_info.append(
{'port': port, 'pci': pci_bus, 'type': pci_id, 'numa': numa,
'intf': intf, 'mac': macaddr})
def destroy_all_sriov_vfs(self):
pass
def load_portconf(self):
"""
Load port configurations for ports_info. If manually configured infor
not same as auto scanned, still use infor in configuration file.
"""
for port in self.ports_info:
pci_bus = port['pci']
ports_cfg = self.conf.get_ports_config()
if pci_bus in ports_cfg:
port_cfg = ports_cfg[pci_bus]
port_cfg['source'] = 'cfg'
else:
port_cfg = {}
for key in ['intf', 'mac', 'peer', 'source']:
if key in port_cfg:
if key in port and port_cfg[key].lower() != port[key].lower():
self.logger.warning("CONFIGURED %s NOT SAME AS SCANNED!!!" % (key.upper()))
port[key] = port_cfg[key].lower()
if 'numa' in port_cfg:
if port_cfg['numa'] != port['numa']:
self.logger.warning("CONFIGURED NUMA NOT SAME AS SCANNED!!!")
port['numa'] = port_cfg['numa']
def map_available_ports(self):
"""
Load or generate network connection mapping list.
"""
if self.read_cache:
self.ports_map = self.serializer.load(self.PORT_MAP_CACHE_KEY)
if not self.read_cache or self.ports_map is None:
self.map_available_ports_uncached()
self.serializer.save(self.PORT_MAP_CACHE_KEY, self.ports_map)
self.logger.warning("DUT PORT MAP: " + str(self.ports_map))
def map_available_ports_uncached(self):
"""
Generate network connection mapping list.
"""
pass
def check_port_occupied(self, port):
pass
def get_maximal_vnc_num(self):
pass
def close(self):
"""
Close ssh session of DUT.
"""
pass
def virt_exit(self):
"""
Stop all unstopped hypervisors process
"""
# try to kill all hypervisor process
pass
def crb_exit(self):
"""
Recover all resource before crb exit
"""
self.logger.logger_exit()
#self.enable_tester_ipv6()
self.close()
class VirtDut(DPDKdut):
"""
A connection to the CRB under test.
This class sends commands to the CRB and validates the responses. It is
implemented using either ssh for linuxapp or the terminal server for
baremetal.
All operations are in fact delegated to an instance of either CRBLinuxApp
or CRBBareMetal.
"""
def __init__(self, hyper, crb, serializer, virttype, vm_name, suite, cpu_topo):
self.vm_name = vm_name
self.hyper = hyper
self.cpu_topo = cpu_topo
self.vm_ip = crb['IP']
self.NAME = 'virtdut' + LOG_NAME_SEP + '%s' % self.vm_ip
super(Dut, self).__init__(crb, serializer, self.NAME)
# load port config from suite cfg
self.suite = suite
self.number_of_cores = 0
self.tester = None
self.cores = []
self.architecture = None
self.ports_info = None
self.ports_map = []
self.virttype = virttype
def init_log(self):
self.logger.config_suite(self.host_dut.test_classname, 'virtdut')
def close(self, force=False):
if self.session:
self.session.close(force)
self.session = None
if self.alt_session:
self.alt_session.close(force)
self.alt_session = None
RemoveNicObj(self)
def set_nic_type(self, nic_type):
"""
Set CRB NICS ready to validated.
"""
self.nic_type = nic_type
# vm_dut config will load from vm configuration file
def load_portconf(self):
"""
Load port config for this virtual machine
"""
self.conf = PortConf()
self.conf.load_ports_config(self.vm_name)
self.ports_cfg = self.conf.get_ports_config()
return
def create_portmap(self):
# if not config ports in vm port config file, used ping6 get portmap
if not self.ports_cfg:
self.map_available_ports()
port_num = len(self.ports_info)
self.ports_map = [-1] * port_num
for key in self.ports_cfg.keys():
index = int(key)
if index >= port_num:
print utils.RED("Can not found [%d ]port info" % index)
continue
if 'peer' in self.ports_cfg[key].keys():
tester_pci = self.ports_cfg[key]['peer']
# find tester_pci index
pci_idx = self.tester.get_local_index(tester_pci)
self.ports_map[index] = pci_idx
def set_target(self, target, bind_dev=True):
"""
Set env variable, these have to be setup all the time. Some tests
need to compile example apps by themselves and will fail otherwise.
Set hugepage on DUT and install modules required by DPDK.
Configure default ixgbe PMD function.
"""
self.set_toolchain(target)
# set env variable
# These have to be setup all the time. Some tests need to compile
# example apps by themselves and will fail otherwise.
self.send_expect("export RTE_TARGET=" + target, "#")
self.send_expect("export RTE_SDK=`pwd`", "#")
if not self.skip_setup:
self.build_install_dpdk(target)
self.setup_memory(hugepages=1024)
self.setup_modules(target)
if bind_dev:
self.bind_interfaces_linux('igb_uio')
def prerequisites(self, pkgName, patch):
"""
Prerequest function should be called before execute any test case.
Will call function to scan all lcore's information which on DUT.
Then call pci scan function to collect nic device information.
At last setup DUT' environment for validation.
"""
if not self.skip_setup:
self.prepare_package()
self.send_expect("cd %s" % self.base_dir, "# ")
self.send_expect("alias ls='ls --color=none'", "#")
if self.get_os_type() == 'freebsd':
self.send_expect('alias make=gmake', '# ')
self.send_expect('alias sed=gsed', '# ')
self.init_core_list()
self.pci_devices_information()
# scan ports before restore interface
self.scan_ports()
# update with real numa id
self.update_ports()
# restore dut ports to kernel
if self.virttype != 'XEN':
self.restore_interfaces()
else:
self.restore_interfaces_domu()
# rescan ports after interface up
self.rescan_ports()
# no need to rescan ports for guest os just bootup
# load port infor from config file
self.load_portconf()
# enable tester port ipv6
self.host_dut.enable_tester_ipv6()
self.mount_procfs()
self.create_portmap()
# disable tester port ipv6
self.host_dut.disable_tester_ipv6()
# print latest ports_info
for port_info in self.ports_info:
self.logger.info(port_info)
def init_core_list(self):
self.cores = []
cpuinfo = self.send_expect("grep --color=never \"processor\""
" /proc/cpuinfo", "#", alt_session=False)
cpuinfo = cpuinfo.split('\r\n')
if self.cpu_topo != '':
topo_reg = r"(\d)S/(\d)C/(\d)T"
m = re.match(topo_reg, self.cpu_topo)
if m:
socks = int(m.group(1))
cores = int(m.group(2))
threads = int(m.group(3))
total = socks * cores * threads
cores_persock = cores * threads
total_phycores = socks * cores
# cores should match cpu_topo
if total != len(cpuinfo):
print utils.RED("Core number not matched!!!")
else:
for core in range(total):
thread = core / total_phycores
phy_core = core % total_phycores
# if this core is hyper core
if thread:
idx = core % total_phycores
socket = idx / cores
else:
socket = core / cores
# tricky here, socket must be string
self.cores.append({'thread': core,
'socket': str(socket),
'core': phy_core})
self.number_of_cores = len(self.cores)
return
# default core map
for line in cpuinfo:
m = re.search("processor\t: (\d+)", line)
if m:
thread = m.group(1)
socket = 0
core = thread
self.cores.append(
{'thread': thread, 'socket': socket, 'core': core})
self.number_of_cores = len(self.cores)
def restore_interfaces_domu(self):
"""
Restore Linux interfaces.
"""
for port in self.ports_info:
pci_bus = port['pci']
pci_id = port['type']
driver = settings.get_nic_driver(pci_id)
if driver is not None:
addr_array = pci_bus.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
itf = port.get_interface_name()
self.send_expect("ifconfig %s up" % itf, "# ")
time.sleep(30)
print self.send_expect("ip link ls %s" % itf, "# ")
else:
self.logger.info(
"NOT FOUND DRIVER FOR PORT (%s|%s)!!!" % (pci_bus, pci_id))
def pci_devices_information(self):
self.pci_devices_information_uncached()
def get_memory_channels(self):
"""
Virtual machine has no memory channel concept, so always return 1
"""
return 1
def check_ports_available(self, pci_bus, pci_id):
"""
Check that whether auto scanned ports ready to use
"""
pci_addr = "%s:%s" % (pci_bus, pci_id)
if pci_id == "8086:100e":
return False
return True
# load vm port conf need another function
# need add vitrual function device into NICS
def scan_ports(self):
"""
Scan ports information, for vm will always scan
"""
self.scan_ports_uncached()
def scan_ports_uncached(self):
"""
Scan ports and collect port's pci id, mac adress, ipv6 address.
"""
scan_ports_uncached = getattr(
self, 'scan_ports_uncached_%s' % self.get_os_type())
return scan_ports_uncached()
def update_ports(self):
"""
Update ports information, according to host pci
"""
for port in self.ports_info:
vmpci = port['pci']
for pci_map in self.hyper.pci_maps:
# search pci mapping strucutre
if vmpci == pci_map['guestpci']:
hostpci = pci_map['hostpci']
# search host port info structure
for hostport in self.host_dut.ports_info:
# update port numa
if hostpci == hostport['pci']:
port['numa'] = hostport['numa']
port['port'].socket = hostport['numa']
break
if 'sriov_vfs_pci' in hostport and \
hostpci in hostport['sriov_vfs_pci']:
port['numa'] = hostport['numa']
port['port'].socket = hostport['numa']
break
def map_available_ports(self):
"""
Load or generate network connection mapping list.
"""
self.map_available_ports_uncached()
self.logger.warning("VM DUT PORT MAP: " + str(self.ports_map))
def map_available_ports_uncached(self):
"""
Generate network connection mapping list.
"""
nrPorts = len(self.ports_info)
if nrPorts == 0:
return
remove = []
self.ports_map = [-1] * nrPorts
hits = [False] * len(self.tester.ports_info)
for vmPort in range(nrPorts):
vmpci = self.ports_info[vmPort]['pci']
peer = self.get_peer_pci(vmPort)
# if peer pci configured
if peer is not None:
for remotePort in range(len(self.tester.ports_info)):
if self.tester.ports_info[remotePort]['pci'] == peer:
hits[remotePort] = True
self.ports_map[vmPort] = remotePort
break
if self.ports_map[vmPort] == -1:
self.logger.error("CONFIGURED TESTER PORT CANNOT FOUND!!!")
else:
continue # skip ping6 map
# strip pci address on host for pass-through device
hostpci = 'N/A'
for pci_map in self.hyper.pci_maps:
if vmpci == pci_map['guestpci']:
hostpci = pci_map['hostpci']
break
# auto ping port map
for remotePort in range(len(self.tester.ports_info)):
# for two vfs connected to same tester port
# need skip ping from devices on same pf device
remotepci = self.tester.ports_info[remotePort]['pci']
port_type = self.tester.ports_info[remotePort]['type']
# IXIA port should not check whether has vfs
if port_type != 'ixia':
remoteport = self.tester.ports_info[remotePort]['port']
vfs = []
# vm_dut and tester in same dut
host_ip = self.crb['IP'].split(':')[0]
if self.crb['tester IP'] == host_ip:
vfs = remoteport.get_sriov_vfs_pci()
# if hostpci is vf of tester port
if hostpci == remotepci or hostpci in vfs:
print utils.RED("Skip ping from same PF device")
continue
ipv6 = self.get_ipv6_address(vmPort)
if ipv6 == "Not connected":
continue
out = self.tester.send_ping6(
remotePort, ipv6, self.get_mac_address(vmPort))
if ('64 bytes from' in out):
self.logger.info(
"PORT MAP: [dut %d: tester %d]" % (vmPort, remotePort))
self.ports_map[vmPort] = remotePort
hits[remotePort] = True
continue
