openstack/os-net-config
Code Issues Proposed changes

Merge "vDPA support for CentOS9"

Browse Source
This commit is contained in:
Zuul 2022-01-06 07:08:48 +00:00 committed by Gerrit Code Review
commit 2eaf566867
12 changed files with 509 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
os_net_config/common.py
View File

@ -22,12 +22,47 @@
import logging
import logging.handlers
import os
from oslo_concurrency import processutils
import sys
import yaml
# File to contain the DPDK mapped nics, as nic name will not be available after
# binding driver, which is required for correct nic numbering.
# Format of the file (list mapped nic's details):
# -
# name: eth1
# pci_address: 0000:02:00.0
# mac_address: 01:02:03:04:05:06
# driver: vfio-pci
DPDK_MAPPING_FILE = '/var/lib/os-net-config/dpdk_mapping.yaml'
# File to contain the list of SR-IOV PF, VF and their configurations
# Format of the file shall be
# - device_type: pf
# name: <pf name>
# numvfs: <number of VFs>
# promisc: "on"/"off"
# - device_type: vf
# device:
# name: <pf name>
# vfid: <VF id>
# name: <vf name>
# vlan_id: <vlan>
# qos: <qos>
# spoofcheck: "on"/"off"
# trust: "on"/"off"
# state: "auto"/"enable"/"disable"
# macaddr: <mac address>
# promisc: "on"/"off"
SRIOV_CONFIG_FILE = '/var/lib/os-net-config/sriov_config.yaml'
SYS_CLASS_NET = '/sys/class/net'
_LOG_FILE = '/var/log/os-net-config.log'
MLNX_VENDOR_ID = "0x15b3"
logger = logging.getLogger(__name__)
def configure_logger(log_file=False, verbose=False, debug=False):
LOG_FORMAT = ('%(asctime)s.%(msecs)03d %(levelname)s '
@ -87,6 +122,96 @@ def get_device_id(ifname):
return
def get_file_data(filename):
if not os.path.exists(filename):
return ''
try:
with open(filename, 'r') as f:
return f.read()
except IOError:
logger.error(f"Error reading file: {filename}")
return ''
def get_sriov_map(pf_name=None):
contents = get_file_data(SRIOV_CONFIG_FILE)
sriov_map = yaml.safe_load(contents) if contents else []
if len(sriov_map) and pf_name:
return [pf for pf in sriov_map if pf['name'] == pf_name]
return sriov_map
def _get_dpdk_mac_address(name):
contents = get_file_data(DPDK_MAPPING_FILE)
dpdk_map = yaml.safe_load(contents) if contents else []
for item in dpdk_map:
if item['name'] == name:
return item['mac_address']
def interface_mac(name):
try: # If the iface is part of a Linux bond, the real MAC is only here.
with open(get_dev_path(name, 'bonding_slave/perm_hwaddr'),
'r') as f:
return f.read().rstrip()
except IOError:
pass # Iface is not part of a bond, continue
try:
with open(get_dev_path(name, '_address'), 'r') as f:
return f.read().rstrip()
except IOError:
# If the interface is bound to a DPDK driver, get the mac address from
# the DPDK mapping file as /sys files will be removed after binding.
dpdk_mac_address = _get_dpdk_mac_address(name)
if dpdk_mac_address:
return dpdk_mac_address
logger.error("Unable to read mac address: %s" % name)
raise
def is_mellanox_interface(ifname):
vendor_id = get_vendor_id(ifname)
return vendor_id == MLNX_VENDOR_ID
def list_kmods(mods: list) -> list:
"""Listing Kernel Modules
Checks in currently loaded modules for a list
of modules and returns the ones that are not loaded
"""
try:
stdout, stderr = processutils.execute('lsmod')
except processutils.ProcessExecutionError as exc:
logger.error(f"Failed to get lsmod: {exc}")
raise
modules = set([line.split()[0] for line in stdout.strip().split('\n')])
return list(set(mods) - set(modules))
def load_kmods(mods: list):
"""Loading Kernel Modules
Loads modules from list that are not already loaded
"""
needed = list_kmods(mods)
for mod in needed:
try:
stdout, stderr = processutils.execute('modprobe', mod)
except processutils.ProcessExecutionError as exc:
logger.error(f"Failed to modprobe {mod}: {exc}")
raise
def restorecon(path: str):
"""Executes restorecon on a path"""
logger.info(f"Restoring selinux context on {path}")
try:
stdout, stderr = processutils.execute('restorecon', '-R', '-F', '-v',
path)
except processutils.ProcessExecutionError as exc:
logger.error(f"Failed to restorecon on {path}: {exc}")
raise
logger.debug(f"Restorecon completed: {stdout}")

5
os_net_config/impl_eni.py
View File

@ -18,10 +18,10 @@ import logging
import netaddr
import os_net_config
from os_net_config import common
from os_net_config import objects
from os_net_config import utils
logger = logging.getLogger(__name__)
@ -98,7 +98,8 @@ class ENINetConfig(os_net_config.NetConfig):
if isinstance(mem, objects.Interface):
data += " pre-up ip addr flush dev %s\n" % mem.name
if interface.primary_interface_name:
mac = utils.interface_mac(interface.primary_interface_name)
mac = common.interface_mac(
interface.primary_interface_name)
ovs_extra.append("set bridge %s other-config:hwaddr=%s" %
(interface.name, mac))
ovs_extra.extend(interface.ovs_extra)

20
os_net_config/impl_ifcfg.py
View File

@ -248,7 +248,7 @@ class IfcfgNetConfig(os_net_config.NetConfig):
:returns: boolean value for whether a restart is required
"""
file_data = utils.get_file_data(filename)
file_data = common.get_file_data(filename)
logger.debug("Original ifcfg file:\n%s" % file_data)
logger.debug("New ifcfg file:\n%s" % new_data)
file_values = self.parse_ifcfg(file_data)
@ -292,7 +292,7 @@ class IfcfgNetConfig(os_net_config.NetConfig):
:returns: commands (commands to be run)
"""
previous_cfg = utils.get_file_data(filename)
previous_cfg = common.get_file_data(filename)
file_values = self.parse_ifcfg(previous_cfg)
data_values = self.parse_ifcfg(data)
logger.debug("File values:\n%s" % file_values)
@ -341,7 +341,7 @@ class IfcfgNetConfig(os_net_config.NetConfig):
:return: list of commands to feed to 'ip' to reconfigure routes
"""
file_values = self.parse_ifcfg_routes(utils.get_file_data(filename))
file_values = self.parse_ifcfg_routes(common.get_file_data(filename))
data_values = self.parse_ifcfg_routes(data)
route_changes = self.enumerate_ifcfg_route_changes(file_values,
data_values)
@ -366,7 +366,7 @@ class IfcfgNetConfig(os_net_config.NetConfig):
:return: list of commands to feed to 'ip' to reconfigure route rules
"""
file_values = self.parse_ifcfg_rules(utils.get_file_data(filename))
file_values = self.parse_ifcfg_rules(common.get_file_data(filename))
data_values = self.parse_ifcfg_rules(data)
rule_changes = self.enumerate_ifcfg_rule_changes(file_values,
data_values)
@ -473,7 +473,7 @@ class IfcfgNetConfig(os_net_config.NetConfig):
if base_opt.use_dhcp:
data += ("OVSDHCPINTERFACES=\"%s\"\n" % " ".join(members))
if base_opt.primary_interface_name:
mac = utils.interface_mac(base_opt.primary_interface_name)
mac = common.interface_mac(base_opt.primary_interface_name)
ovs_extra.append("set bridge %s other-config:hwaddr=%s" %
(base_opt.name, mac))
if base_opt.ovs_options:
@ -517,12 +517,12 @@ class IfcfgNetConfig(os_net_config.NetConfig):
self.member_names[base_opt.name] = members
if base_opt.primary_interface_name:
primary_name = base_opt.primary_interface_name
primary_mac = utils.interface_mac(primary_name)
primary_mac = common.interface_mac(primary_name)
data += "MACADDR=\"%s\"\n" % primary_mac
elif isinstance(base_opt, objects.LinuxBond):
if base_opt.primary_interface_name:
primary_name = base_opt.primary_interface_name
primary_mac = utils.interface_mac(primary_name)
primary_mac = common.interface_mac(primary_name)
data += "MACADDR=\"%s\"\n" % primary_mac
if base_opt.use_dhcp:
data += "BOOTPROTO=dhcp\n"
@ -534,7 +534,7 @@ class IfcfgNetConfig(os_net_config.NetConfig):
elif isinstance(base_opt, objects.LinuxTeam):
if base_opt.primary_interface_name:
primary_name = base_opt.primary_interface_name
primary_mac = utils.interface_mac(primary_name)
primary_mac = common.interface_mac(primary_name)
data += "MACADDR=\"%s\"\n" % primary_mac
if base_opt.use_dhcp:
data += "BOOTPROTO=dhcp\n"
@ -1069,7 +1069,7 @@ class IfcfgNetConfig(os_net_config.NetConfig):
if not vpp_interface.pci_dev:
vpp_interface.pci_dev = utils.get_stored_pci_address(
vpp_interface.name, False)
vpp_interface.hwaddr = utils.interface_mac(vpp_interface.name)
vpp_interface.hwaddr = common.interface_mac(vpp_interface.name)
if not self.noop:
self.ifdown(vpp_interface.name)
remove_ifcfg_config(vpp_interface.name)
@ -1210,7 +1210,7 @@ class IfcfgNetConfig(os_net_config.NetConfig):
custom_tables = {}
res_ids = ['0', '253', '254', '255']
res_names = ['unspec', 'default', 'main', 'local']
rt_config = utils.get_file_data(route_table_config_path()).split('\n')
rt_config = common.get_file_data(route_table_config_path()).split('\n')
rt_defaults = _ROUTE_TABLE_DEFAULT.split("\n")
data = _ROUTE_TABLE_DEFAULT
for line in (line for line in rt_config if line not in rt_defaults):

5
os_net_config/objects.py
View File

@ -23,6 +23,7 @@ import logging
import netaddr
from oslo_utils import strutils
from os_net_config import common
from os_net_config import utils
@ -151,7 +152,7 @@ def mapped_nics(nic_mapping=None):
# If 'nic' is actually a mac address, retrieve actual nic name
for nic in available_nics:
try:
mac = utils.interface_mac(nic)
mac = common.interface_mac(nic)
except IOError:
continue
if nic_mapped == mac:
@ -352,7 +353,7 @@ class _BaseOpts(object):
self.name = name
self.hwname = '%s%s' % (mapped_nic_names[base_name],
vlan_suffix)
self.hwaddr = utils.interface_mac(self.hwname)
self.hwaddr = common.interface_mac(self.hwname)
self.renamed = True
else:
self.name = '%s%s' % (mapped_nic_names[base_name], vlan_suffix)

307
os_net_config/sriov_config.py
View File

@ -28,8 +28,8 @@ import queue
import re
import sys
import time
import yaml
from json import loads
from os_net_config import common
from os_net_config import sriov_bind_config
from oslo_concurrency import processutils
@ -43,9 +43,16 @@ _RESET_SRIOV_RULES_FILE = '/etc/udev/rules.d/70-tripleo-reset-sriov.rules'
_ALLOCATE_VFS_FILE = '/etc/sysconfig/allocate_vfs'
_MLNX_DRIVER = "mlx5_core"
MLNX_UNBIND_FILE_PATH = "/sys/bus/pci/drivers/mlx5_core/unbind"
MLNX5_VDPA_KMODS = [
"vdpa",
"vhost_vdpa",
"mlx5_vdpa",
]
MAX_RETRIES = 10
PF_FUNC_RE = re.compile(r"\.(\d+)$", 0)
VF_PCI_RE = re.compile(r'/[\d]{4}\:(\d+):(\d+)\.(\d+)/net/[^\/]+$')
# In order to keep VF representor name consistent specially after the upgrade
# proccess, we should have a udev rule to handle that.
# The udev rule will rename the VF representor as "<sriov_pf_name>_<vf_num>"
@ -61,25 +68,9 @@ echo "NUMBER=${PORT##pf*vf}"
vf_queue = queue.Queue()
# File to contain the list of SR-IOV PF, VF and their configurations
# Format of the file shall be
# - device_type: pf
# name: <pf name>
# numvfs: <number of VFs>
# promisc: "on"/"off"
# - device_type: vf
# device:
# name: <pf name>
# vfid: <VF id>
# name: <vf name>
# vlan_id: <vlan>
# qos: <qos>
# spoofcheck: "on"/"off"
# trust: "on"/"off"
# state: "auto"/"enable"/"disable"
# macaddr: <mac address>
# promisc: "on"/"off"
_SRIOV_CONFIG_FILE = '/var/lib/os-net-config/sriov_config.yaml'
# Global variable to store link between pci/pf
# for udev rule creationg when dealing with mlnx vdpa
vf_to_pf = {}
class SRIOVNumvfsException(ValueError):
@ -94,50 +85,79 @@ def udev_event_handler(action, device):
vf_queue.put(event)
def get_file_data(filename):
if not os.path.exists(filename):
return ''
try:
with open(filename, 'r') as f:
return f.read()
except IOError:
logger.error(f"Error reading file: {filename}")
return ''
def _norm_path(dev, suffix):
return os.path.normpath(os.path.join(dev, suffix))
def _get_sriov_map():
contents = get_file_data(_SRIOV_CONFIG_FILE)
sriov_map = yaml.safe_load(contents) if contents else []
return sriov_map
def _get_pf_path(device):
pf_path = _norm_path(device, "../../physfn/net")
if not os.path.isdir(pf_path):
pf_path = _norm_path(device, "physfn/net")
if not os.path.isdir(pf_path):
pf_path = None
return pf_path
def _driver_unbind(dev):
vf_pci_path = f"/sys/bus/pci/devices/{dev}/driver"
if os.path.exists(vf_pci_path):
logger.info(f"{dev}: Unbinding driver")
with open(MLNX_UNBIND_FILE_PATH, 'w') as f:
f.write(dev)
else:
logger.info(f"{dev}: No driver to unbind")
def _wait_for_vf_creation(pf_name, numvfs):
vf_count = 0
vf_list = []
pf_config = common.get_sriov_map(pf_name)
vdpa = False
if len(pf_config):
vdpa = pf_config[0].get('vdpa', False)
while vf_count < numvfs:
try:
# wait for 5 seconds after every udev event
event = vf_queue.get(True, 5)
vf_name = os.path.basename(event["device"])
pf_path = os.path.normpath(os.path.join(event["device"],
"../../physfn/net"))
if os.path.isdir(pf_path):
pf_path = _get_pf_path(event["device"])
logger.debug(f"{event['device']}: Got udev event: {event}")
if pf_path:
pf_nic = os.listdir(pf_path)
if len(pf_nic) == 1 and pf_name == pf_nic[0]:
if vf_name not in vf_list:
vf_list.append(vf_name)
# NOTE(dvd): For vDPA devices, the VF event we're interrested
# in contains all the VFs. We can also use this to build a dict
# to correlate the VF pci address to the PF when creating the
# vdpa representator udev rule
#
# Data structure sample for vDPA:
# pf_path:
# /sys/devices/pci0000:00/0000:00:02.2/0000:06:01.2/physfn/net
# pf_nic: ['enp6s0f1np1_0', 'enp6s0f1np1_1', 'enp6s0f1np1']
# pf_name: enp6s0f1np1
if vf_name not in vf_to_pf and pf_name in pf_nic:
vf_to_pf[vf_name] = {
'device': event['device'],
'pf': pf_name
}
logger.info(
f"VF: {vf_name} created for PF: {pf_name}"
f"{pf_name}: VF {vf_name} created"
)
vf_count = vf_count + 1
vf_count += 1
elif vf_name in vf_to_pf:
logger.debug(
f"{pf_name}: VF {vf_name} was already created"
)
elif vdpa:
logger.warning(f"{pf_name}: This PF is not in {pf_path}")
else:
logger.warning(f"Unable to parse event {event['device']}")
else:
logger.warning(f"{pf_path} is not a directory")
logger.warning(
f"{pf_name}: Unable to parse event {event['device']}"
)
elif not vdpa:
logger.warning(f"{event['device']}: Unable to find PF")
except queue.Empty:
logger.info(f"Timeout in the creation of VFs for PF {pf_name}")
logger.info(f"{pf_name}: Timeout in the creation of VFs")
return
logger.info(f"Required VFs are created for PF {pf_name}")
logger.info(f"{pf_name}: Required VFs are created")
def get_numvfs(ifname):
@ -150,14 +170,14 @@ def get_numvfs(ifname):
:raises: SRIOVNumvfsException
"""
sriov_numvfs_path = common.get_dev_path(ifname, "sriov_numvfs")
logger.debug(f"Getting numvfs for interface {ifname}")
logger.debug(f"{ifname}: Getting numvfs for interface")
try:
with open(sriov_numvfs_path, 'r') as f:
curr_numvfs = int(f.read())
except IOError as exc:
msg = f"Unable to read numvfs for {ifname}: {exc}"
msg = f"{ifname}: Unable to read numvfs: {exc}"
raise SRIOVNumvfsException(msg)
logger.debug(f"Interface {ifname} has {curr_numvfs} configured")
logger.debug(f"{ifname}: Interface has {curr_numvfs} configured")
return curr_numvfs
@ -179,17 +199,17 @@ def set_numvfs(ifname, numvfs):
:raises: SRIOVNumvfsException
"""
curr_numvfs = get_numvfs(ifname)
logger.debug(f"Interface {ifname} has {curr_numvfs} configured, setting "
logger.debug(f"{ifname}: Interface has {curr_numvfs} configured, setting "
f"to {numvfs}")
if not isinstance(numvfs, int):
msg = (f"Unable to configure pf: {ifname} with numvfs: {numvfs}\n"
msg = (f"{ifname}: Unable to configure pf with numvfs: {numvfs}\n"
f"numvfs must be an integer")
raise SRIOVNumvfsException(msg)
if numvfs != curr_numvfs:
if curr_numvfs != 0:
logger.warning(f"Numvfs already configured to {curr_numvfs} for "
f"{ifname}")
logger.warning(f"{ifname}: Numvfs already configured to "
f"{curr_numvfs}")
return curr_numvfs
sriov_numvfs_path = common.get_dev_path(ifname, "sriov_numvfs")
@ -198,14 +218,14 @@ def set_numvfs(ifname, numvfs):
with open(sriov_numvfs_path, "w") as f:
f.write("%d" % numvfs)
except IOError as exc:
msg = (f"Unable to configure pf: {ifname} with numvfs: {numvfs}\n"
msg = (f"{ifname} Unable to configure pf with numvfs: {numvfs}\n"
f"{exc}")
raise SRIOVNumvfsException(msg)
_wait_for_vf_creation(ifname, numvfs)
curr_numvfs = get_numvfs(ifname)
if curr_numvfs != numvfs:
msg = (f"Unable to configure pf: {ifname} with numvfs: {numvfs}\n"
msg = (f"{ifname}: Unable to configure pf with numvfs: {numvfs}\n"
"sriov_numvfs file is not set to the targeted number of "
"vfs")
raise SRIOVNumvfsException(msg)
@ -213,7 +233,7 @@ def set_numvfs(ifname, numvfs):
def restart_ovs_and_pfs_netdevs():
sriov_map = _get_sriov_map()
sriov_map = common.get_sriov_map()
processutils.execute('/usr/bin/systemctl', 'restart', 'openvswitch')
for item in sriov_map:
if item['device_type'] == 'pf':
@ -265,14 +285,14 @@ def is_partitioned_pf(dev_name: str) -> bool:
Given a PF device, returns True if any VFs of this
device are in-use.
"""
sriov_map = _get_sriov_map()
sriov_map = common.get_sriov_map()
for config in sriov_map:
devtype = config.get('device_type', None)
if devtype == 'vf':
name = config.get('device', {}).get('name')
vf_name = config.get('name')
if dev_name == name:
logger.warning("%s has VF(%s) used by host" % (name, vf_name))
logger.warning(f"{name} has VF({vf_name}) used by host")
return True
return False
@ -281,12 +301,15 @@ def configure_sriov_pf(execution_from_cli=False, restart_openvswitch=False):
observer = udev_monitor_setup()
udev_monitor_start(observer)
sriov_map = _get_sriov_map()
mlnx_vfs_pcis_list = []
sriov_map = common.get_sriov_map()
dpdk_vfs_pcis_list = []
trigger_udev_rule = False
# Cleanup the previous config by puppet-tripleo
cleanup_puppet_config()
if any(item.get('vdpa') for item in sriov_map):
common.load_kmods(MLNX5_VDPA_KMODS)
vdpa_devices = get_vdpa_vhost_devices()
for item in sriov_map:
if item['device_type'] == 'pf':
@ -300,23 +323,30 @@ def configure_sriov_pf(execution_from_cli=False, restart_openvswitch=False):
# When configuring vdpa, we need to configure switchdev before
# we create the VFs
is_mlnx = common.is_mellanox_interface(item['name'])
vdpa = item.get('vdpa')
# Configure switchdev mode when vdpa
if item.get('vdpa') and is_mlnx:
# It has to happen before we set_numvfs
if vdpa and is_mlnx:
configure_switchdev(item['name'])
set_numvfs(item['name'], item['numvfs'])
# Configure switchdev mode when not vdpa
if (item.get('link_mode') == "switchdev" and is_mlnx and
not item.get('vdpa')):
# Configure switchdev, unbind driver and configure vdpa
if item.get('link_mode') == "switchdev" and is_mlnx:
logger.info(f"{item['name']}: Mellanox card")
vf_pcis_list = get_vf_pcis_list(item['name'])
mlnx_vfs_pcis_list += vf_pcis_list
for vf_pci in vf_pcis_list:
vf_pci_path = f"/sys/bus/pci/devices/{vf_pci}/driver"
if os.path.exists(vf_pci_path):
logger.info(f"Unbinding {vf_pci}")
with open(MLNX_UNBIND_FILE_PATH, 'w') as f:
f.write(vf_pci)
if not vdpa:
# For DPDK, we need to unbind the driver
_driver_unbind(vf_pci)
else:
if vf_pci not in vdpa_devices:
configure_vdpa_vhost_device(vf_pci)
else:
logger.info(
f"{item['name']}: vDPA device already created "
f"for {vf_pci}"
)
if vdpa:
common.restorecon('/dev/vhost-*')
logger.info(f"{item['name']}: Adding udev rules")
# Adding a udev rule to make vf-representors unmanaged by
# NetworkManager
@ -326,13 +356,18 @@ def configure_sriov_pf(execution_from_cli=False, restart_openvswitch=False):
trigger_udev_rule = add_udev_rule_for_sriov_pf(item['name'])\
or trigger_udev_rule
configure_smfs_software_steering(item['name'])
trigger_udev_rule = add_udev_rule_for_vf_representors(
item['name']) or trigger_udev_rule
if not vdpa:
# This is used for the sriov_bind_config
dpdk_vfs_pcis_list += vf_pcis_list
configure_smfs_software_steering(item['name'])
# Configure switchdev mode
configure_switchdev(item['name'])
# Adding a udev rule to rename vf-representors
trigger_udev_rule = add_udev_rule_for_vf_representors(
else:
trigger_udev_rule = add_udev_rule_for_vdpa_representors(
item['name']) or trigger_udev_rule
# Moving the sriov-PFs to switchdev mode will put the netdev
@ -345,8 +380,8 @@ def configure_sriov_pf(execution_from_cli=False, restart_openvswitch=False):
if execution_from_cli:
if_up_interface(item['name'])
if mlnx_vfs_pcis_list:
sriov_bind_pcis_map = {_MLNX_DRIVER: mlnx_vfs_pcis_list}
if dpdk_vfs_pcis_list and not vdpa:
sriov_bind_pcis_map = {_MLNX_DRIVER: dpdk_vfs_pcis_list}
if not execution_from_cli:
sriov_bind_config.update_sriov_bind_pcis_map(sriov_bind_pcis_map)
else:
@ -366,13 +401,12 @@ def _wait_for_uplink_rep_creation(pf_name):
uplink_rep_phys_switch_id_path = f"/sys/class/net/{pf_name}/phys_switch_id"
for i in range(MAX_RETRIES):
if get_file_data(uplink_rep_phys_switch_id_path):
logger.info(f"Uplink representor {pf_name} ready")
if common.get_file_data(uplink_rep_phys_switch_id_path):
logger.info(f"{pf_name} Uplink representor ready")
break
time.sleep(1)
else:
raise RuntimeError(f"Timeout while waiting for uplink representor "
f"{pf_name}.")
raise RuntimeError(f"{pf_name}: Timeout waiting uplink representor")
def create_rep_link_name_script():
@ -383,7 +417,7 @@ def create_rep_link_name_script():
def add_udev_rule_for_sriov_pf(pf_name):
logger.info(f"adding udev rules for sriov {pf_name}")
logger.info(f"{pf_name}: adding udev rules for sriov")
pf_pci = get_pf_pci(pf_name)
udev_data_line = 'SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", '\
f'KERNELS=="{pf_pci}", NAME="{pf_name}"'
@ -391,7 +425,7 @@ def add_udev_rule_for_sriov_pf(pf_name):
def add_udev_rule_for_legacy_sriov_pf(pf_name, numvfs):
logger.info(f"adding udev rules for legacy sriov {pf_name}: {numvfs}")
logger.info(f"{pf_name}: adding udev rules for legacy sriov: {numvfs}")
udev_line = f'KERNEL=="{pf_name}", '\
f'RUN+="/bin/os-net-config-sriov -n %k:{numvfs}"'
pattern = f'KERNEL=="{pf_name}", RUN+="/bin/os-net-config-sriov -n'
@ -399,20 +433,19 @@ def add_udev_rule_for_legacy_sriov_pf(pf_name, numvfs):
def add_udev_rule_for_vf_representors(pf_name):
logger.info(f"adding udev rules for vf representators {pf_name}")
phys_switch_id_path = os.path.join(common.SYS_CLASS_NET, pf_name,
"phys_switch_id")
phys_switch_id = get_file_data(phys_switch_id_path).strip()
logger.info(f"{pf_name}: adding udev rules for vf representators")
phys_switch_id_path = common.get_dev_path(pf_name,
"_phys_switch_id")
phys_switch_id = common.get_file_data(phys_switch_id_path).strip()
pf_pci = get_pf_pci(pf_name)
pf_fun_num_match = PF_FUNC_RE.search(pf_pci)
if pf_fun_num_match:
pf_fun_num = pf_fun_num_match.group(1)
else:
logger.error(f"Failed to get function number for {pf_name} \n"
if not pf_fun_num_match:
logger.error(f"{pf_name}: Failed to get function number "
"and so failed to create a udev rule for renaming "
"its' vf-represent")
"its vf-represent")
return
pf_fun_num = pf_fun_num_match.group(1)
udev_data_line = 'SUBSYSTEM=="net", ACTION=="add", ATTR{phys_switch_id}'\
'=="%s", ATTR{phys_port_name}=="pf%svf*", '\
'IMPORT{program}="%s $attr{phys_port_name}", '\
@ -424,8 +457,29 @@ def add_udev_rule_for_vf_representors(pf_name):
return add_udev_rule(udev_data_line, _UDEV_RULE_FILE)
def add_udev_rule_for_vdpa_representors(pf_name):
logger.info(f"{pf_name}: adding udev rules for vdpa representators")
udev_lines = ""
for vf, att in vf_to_pf.items():
mac = common.interface_mac(vf)
vadd = VF_PCI_RE.search(att.get('device'))
if not vadd:
logger.error(
f"{att.get('device')}/{vf}: Failed to get pf/vf numbers "
"and so failed to create a udev rule for renaming vdpa dev"
)
continue
vdpa_rep = f"vdpa{vadd.group(1)}p{vadd.group(2)}vf{vadd.group(3)}"
logger.info(f"{vdpa_rep}: Adding udev representor rule.")
udev_lines += (
'SUBSYSTEM=="net", ACTION=="add", '
f'ATTR{{address}}=="{mac}", NAME="{vdpa_rep}"\n'
)
return add_udev_rule(udev_lines, _UDEV_RULE_FILE)
def add_udev_rule_to_unmanage_vf_representors_by_nm():
logger.info(f"adding udev rules to unmanage vf representators")
logger.info("adding udev rules to unmanage vf representators")
udev_data_line = 'SUBSYSTEM=="net", ACTION=="add", ATTR{phys_switch_id}'\
'!="", ATTR{phys_port_name}=="pf*vf*", '\
'ENV{NM_UNMANAGED}="1"'
@ -444,7 +498,7 @@ def add_udev_rule(udev_data, udev_file, pattern=None):
f"{udev_data}\n"
f.write(data)
else:
file_data = get_file_data(udev_file)
file_data = common.get_file_data(udev_file)
udev_lines = file_data.splitlines()
if pattern in file_data:
if udev_data in udev_lines:
@ -491,16 +545,17 @@ def configure_switchdev(pf_name):
processutils.execute('/usr/sbin/devlink', 'dev', 'eswitch', 'set',
f'pci/{pf_pci}', 'inline-mode', 'transport')
except processutils.ProcessExecutionError as exc:
logger.error(f"Failed to set inline-mode to transport for "
f"{pf_pci}: {exc}")
logger.error(f"{pf_name}: Failed to set inline-mode to transport "
f"for {pf_pci}: {exc}")
raise
try:
processutils.execute('/usr/sbin/devlink', 'dev', 'eswitch', 'set',
f'pci/{pf_pci}', 'mode', 'switchdev')
except processutils.ProcessExecutionError as exc:
logger.error(f"Failed to set mode to switchdev for {pf_pci}: {exc}")
logger.error(f"{pf_name}: Failed to set mode to switchdev for "
f"{pf_pci}: {exc}")
raise
logger.info(f"Device pci/{pf_pci} set to switchdev mode.")
logger.info(f"{pf_name}: Device pci/{pf_pci} set to switchdev mode.")
# WA to make sure that the uplink_rep is ready after moving to switchdev,
# as moving to switchdev will remove the sriov_pf and create uplink
@ -511,9 +566,29 @@ def configure_switchdev(pf_name):
try:
processutils.execute('/usr/sbin/ethtool', '-K', pf_name,
'hw-tc-offload', 'on')
logger.info(f"Enabled \"hw-tc-offload\" for PF {pf_name}.")
logger.info(f"{pf_name}: Enabled \"hw-tc-offload\" for PF.")
except processutils.ProcessExecutionError as exc:
logger.error(f"Failed to enable hw-tc-offload on {pf_name}: {exc}")
logger.error(f"{pf_name}: Failed to enable hw-tc-offload: {exc}")
raise
def get_vdpa_vhost_devices():
logger.info(f"Getting list of vdpa devices")
try:
stdout, stderr = processutils.execute('vdpa', '-j', 'dev')
except processutils.ProcessExecutionError as exc:
logger.error(f"Failed to get vdpa vhost devices: {exc}")
raise
return loads(stdout)['dev']
def configure_vdpa_vhost_device(pci):
logger.info(f"{pci}: Creating vdpa device")
try:
processutils.execute('vdpa', 'dev', 'add', 'name', pci,
'mgmtdev', f'pci/{pci}')
except processutils.ProcessExecutionError as exc:
logger.error(f"{pci}: Failed to create vdpa vhost device: {exc}")
raise
@ -523,10 +598,11 @@ def configure_smfs_software_steering(pf_name):
processutils.execute('/usr/sbin/devlink', 'dev', 'param', 'set',
f'pci/{pf_pci}', 'name', 'flow_steering_mode',
'value', 'smfs', 'cmode', 'runtime')
logger.info(f"Device pci/{pf_pci} is set to smfs steering mode.")
logger.info(f"{pf_name}: Device pci/{pf_pci} is set to smfs steering "
"mode.")
except processutils.ProcessExecutionError as exc:
logger.warning(f"Could not set pci/{pf_pci} to smfs steering mode: "
f"{exc}")
logger.warning(f"{pf_name}: Could not set pci/{pf_pci} to smfs "
f" steering mode: {exc}")
def run_ip_config_cmd(*cmd, **kwargs):
@ -542,7 +618,7 @@ def _pf_interface_up(pf_device):
if 'promisc' in pf_device:
run_ip_config_cmd('ip', 'link', 'set', 'dev', pf_device['name'],
'promisc', pf_device['promisc'])
logger.info(f"Bringing up PF: {pf_device['name']}")
logger.info(f"{pf_device['name']}: Bringing up PF")
run_ip_config_cmd('ip', 'link', 'set', 'dev', pf_device['name'], 'up')
@ -556,24 +632,23 @@ def run_ip_config_cmd_safe(raise_error, *cmd, **kwargs):
def get_pf_pci(pf_name):
pf_pci_path = common.get_dev_path(pf_name, "uevent")
pf_info = get_file_data(pf_pci_path)
pf_info = common.get_file_data(pf_pci_path)
pf_pci = re.search(r'PCI_SLOT_NAME=(.*)', pf_info, re.MULTILINE).group(1)
return pf_pci
def get_pf_device_id(pf_name):
pf_device_path = common.get_dev_path(pf_name, "device")
pf_device_id = get_file_data(pf_device_path).strip()
pf_device_id = common.get_file_data(pf_device_path).strip()
return pf_device_id
def get_vf_pcis_list(pf_name):
vf_pcis_list = []
listOfPfFiles = os.listdir(os.path.join(common.SYS_CLASS_NET, pf_name,
"device"))
for pf_file in listOfPfFiles:
pf_files = os.listdir(common.get_dev_path(pf_name, "_device"))
for pf_file in pf_files:
if pf_file.startswith("virtfn"):
vf_info = get_file_data(common.get_dev_path(pf_name,
vf_info = common.get_file_data(common.get_dev_path(pf_name,
f"{pf_file}/uevent"))
vf_pcis_list.append(re.search(r'PCI_SLOT_NAME=(.*)',
vf_info, re.MULTILINE).group(1))
@ -581,32 +656,32 @@ def get_vf_pcis_list(pf_name):
def if_down_interface(device):
logger.info(f"Running /sbin/ifdown {device}")
logger.info(f"{device}: Running /sbin/ifdown")
try:
processutils.execute('/sbin/ifdown', device)
except processutils.ProcessExecutionError:
logger.error(f"Failed to ifdown {device}")
logger.error(f"{device}: Failed to ifdown")
raise
def if_up_interface(device):
logger.info(f"Running /sbin/ifup {device}")
logger.info(f"{device}: Running /sbin/ifup")
try:
processutils.execute('/sbin/ifup', device)
except processutils.ProcessExecutionError:
logger.error(f"Failed to ifup {device}")
logger.error(f"{device}: Failed to ifup")
raise
def configure_sriov_vf():
sriov_map = _get_sriov_map()
sriov_map = common.get_sriov_map()
for item in sriov_map:
raise_error = True
if item['device_type'] == 'vf':
pf_name = item['device']['name']
vfid = item['device']['vfid']
base_cmd = ('ip', 'link', 'set', 'dev', pf_name, 'vf', str(vfid))
logger.info(f"Configuring settings for PF: {pf_name} VF: {vfid} "
logger.info(f"{pf_name}: Configuring settings for VF: {vfid} "
f"VF name: {item['name']}")
raise_error = True
if 'macaddr' in item:

22
os_net_config/tests/test_cli.py
View File

@ -24,9 +24,7 @@ import yaml
import os_net_config
from os_net_config import cli
from os_net_config import common
from os_net_config import sriov_config
from os_net_config.tests import base
from os_net_config import utils
REALPATH = os.path.dirname(os.path.realpath(__file__))
@ -39,7 +37,7 @@ class TestCli(base.TestCase):
def setUp(self):
super(TestCli, self).setUp()
rand = str(int(random.random() * 100000))
sriov_config._SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
common.SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
common._LOG_FILE = '/tmp/' + rand + 'os_net_config.log'
sys.stdout = StringIO()
sys.stderr = StringIO()
@ -53,8 +51,8 @@ class TestCli(base.TestCase):
super(TestCli, self).tearDown()
if os.path.isfile(common._LOG_FILE):
os.remove(common._LOG_FILE)
if os.path.isfile(sriov_config._SRIOV_CONFIG_FILE):
os.remove(sriov_config._SRIOV_CONFIG_FILE)
if os.path.isfile(common.SRIOV_CONFIG_FILE):
os.remove(common.SRIOV_CONFIG_FILE)
def run_cli(self, argstr, exitcodes=(0,)):
for s in [sys.stdout, sys.stderr]:
@ -225,7 +223,7 @@ class TestCli(base.TestCase):
test_get_vf_devname)
self.stub_out('os_net_config.utils.get_pci_address',
test_get_pci_address)
self.stub_out('os_net_config.utils.interface_mac',
self.stub_out('os_net_config.common.interface_mac',
test_interface_mac)
ivs_yaml = os.path.join(SAMPLE_BASE, 'sriov_pf.yaml')
ivs_json = os.path.join(SAMPLE_BASE, 'sriov_pf.json')
@ -233,14 +231,14 @@ class TestCli(base.TestCase):
'--exit-on-validation-errors '
'-c %s' % ivs_yaml)
self.assertEqual('', stderr)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_config_yaml = yaml.safe_load(contents)
os.remove(sriov_config._SRIOV_CONFIG_FILE)
os.remove(common.SRIOV_CONFIG_FILE)
stdout_json, stderr = self.run_cli('ARG0 --provider=ifcfg --noop '
'--exit-on-validation-errors '
'-c %s' % ivs_json)
self.assertEqual('', stderr)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_config_json = yaml.safe_load(contents)
sanity_devices = ['DEVICE=p2p1',
'DEVICE=p2p1_5',
@ -270,14 +268,14 @@ class TestCli(base.TestCase):
'--exit-on-validation-errors '
'-c %s' % ivs_yaml)
self.assertEqual('', stderr)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_config_yaml = yaml.safe_load(contents)
os.remove(sriov_config._SRIOV_CONFIG_FILE)
os.remove(common.SRIOV_CONFIG_FILE)
stdout_json, stderr = self.run_cli('ARG0 --provider=ifcfg --noop '
'--exit-on-validation-errors '
'-c %s' % ivs_json)
self.assertEqual('', stderr)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_config_json = yaml.safe_load(contents)
sanity_devices = ['DEVICE=p2p1',
'DEVICE=p2p1_5',

14
os_net_config/tests/test_impl_eni.py
View File

@ -19,10 +19,10 @@ import tempfile
from oslo_concurrency import processutils
import os_net_config
from os_net_config import common
from os_net_config import impl_eni
from os_net_config import objects
from os_net_config.tests import base
from os_net_config import utils
_AUTO = "auto eth0\n"
@ -239,7 +239,7 @@ class TestENINetConfig(base.TestCase):
def test_interface_mac(name):
return "a1:b2:c3:d4:e5"
self.stub_out('os_net_config.utils.interface_mac', test_interface_mac)
self.stub_out('os_net_config.common.interface_mac', test_interface_mac)
interface = objects.Interface(self.if_name, primary=True)
bridge = objects.OvsBridge('br0', use_dhcp=True,
@ -254,7 +254,7 @@ class TestENINetConfig(base.TestCase):
def test_interface_mac(name):
return "a1:b2:c3:d4:e5"
self.stub_out('os_net_config.utils.interface_mac', test_interface_mac)
self.stub_out('os_net_config.common.interface_mac', test_interface_mac)
interface = objects.Interface(self.if_name, primary=True)
ovs_extra = "br-set-external-id br0 bridge-id br0"
@ -271,7 +271,7 @@ class TestENINetConfig(base.TestCase):
def test_interface_mac(name):
return "a1:b2:c3:d4:e5"
self.stub_out('os_net_config.utils.interface_mac', test_interface_mac)
self.stub_out('os_net_config.common.interface_mac', test_interface_mac)
interface = objects.Interface(self.if_name, primary=True)
ovs_extra = "br-set-external-id {name} bridge-id {name}"
@ -344,7 +344,7 @@ class TestENINetConfigApply(base.TestCase):
self.provider.add_interface(interface)
self.provider.apply()
iface_data = utils.get_file_data(self.temp_config_file.name)
iface_data = common.get_file_data(self.temp_config_file.name)
self.assertEqual((_V4_IFACE_STATIC_IP + _RTS), iface_data)
self.assertIn('eth0', self.ifup_interface_names)
@ -358,7 +358,7 @@ class TestENINetConfigApply(base.TestCase):
self.provider.add_interface(interface)
self.provider.apply(activate=False)
iface_data = utils.get_file_data(self.temp_config_file.name)
iface_data = common.get_file_data(self.temp_config_file.name)
self.assertEqual((_V4_IFACE_STATIC_IP + _RTS), iface_data)
self.assertEqual([], self.ifup_interface_names)
@ -369,7 +369,7 @@ class TestENINetConfigApply(base.TestCase):
self.provider.add_interface(interface)
self.provider.add_bridge(bridge)
self.provider.apply()
iface_data = utils.get_file_data(self.temp_config_file.name)
iface_data = common.get_file_data(self.temp_config_file.name)
self.assertEqual((_OVS_BRIDGE_DHCP + _OVS_PORT_IFACE), iface_data)
self.assertIn('eth0', self.ifup_interface_names)
self.assertIn('br0', self.ifup_interface_names)

34
os_net_config/tests/test_impl_ifcfg.py
View File

@ -22,9 +22,9 @@ import tempfile
from oslo_concurrency import processutils
import os_net_config
from os_net_config import common
from os_net_config import impl_ifcfg
from os_net_config import objects
from os_net_config import sriov_config
from os_net_config.tests import base
from os_net_config import utils
@ -657,7 +657,7 @@ class TestIfcfgNetConfig(base.TestCase):
def setUp(self):
super(TestIfcfgNetConfig, self).setUp()
rand = str(int(random.random() * 100000))
sriov_config._SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
common.SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
self.provider = impl_ifcfg.IfcfgNetConfig()
@ -668,8 +668,8 @@ class TestIfcfgNetConfig(base.TestCase):
def tearDown(self):
super(TestIfcfgNetConfig, self).tearDown()
if os.path.isfile(sriov_config._SRIOV_CONFIG_FILE):
os.remove(sriov_config._SRIOV_CONFIG_FILE)
if os.path.isfile(common.SRIOV_CONFIG_FILE):
os.remove(common.SRIOV_CONFIG_FILE)
def get_interface_config(self, name='em1'):
return self.provider.interface_data[name]
@ -807,7 +807,7 @@ class TestIfcfgNetConfig(base.TestCase):
def test_interface_mac(name):
macs = {'em1': 'a1:b2:c3:d4:e5'}
return macs[name]
self.stub_out('os_net_config.utils.interface_mac', test_interface_mac)
self.stub_out('os_net_config.common.interface_mac', test_interface_mac)
nic_mapping = {'nic1': 'em1'}
self.stubbed_mapped_nics = nic_mapping
@ -961,7 +961,7 @@ class TestIfcfgNetConfig(base.TestCase):
def test_network_ovs_bridge_with_dhcp_primary_interface(self):
def test_interface_mac(name):
return "a1:b2:c3:d4:e5"
self.stub_out('os_net_config.utils.interface_mac', test_interface_mac)
self.stub_out('os_net_config.common.interface_mac', test_interface_mac)
interface = objects.Interface('em1', primary=True)
bridge = objects.OvsBridge('br-ctlplane', use_dhcp=True,
@ -975,7 +975,7 @@ class TestIfcfgNetConfig(base.TestCase):
def test_network_ovs_bridge_with_dhcp_primary_interface_with_extra(self):
def test_interface_mac(name):
return "a1:b2:c3:d4:e5"
self.stub_out('os_net_config.utils.interface_mac', test_interface_mac)
self.stub_out('os_net_config.common.interface_mac', test_interface_mac)
interface = objects.Interface('em1', primary=True)
ovs_extra = "br-set-external-id br-ctlplane bridge-id br-ctlplane"
@ -991,7 +991,7 @@ class TestIfcfgNetConfig(base.TestCase):
def test_network_ovs_bridge_with_dhcp_primary_interface_with_format(self):
def test_interface_mac(name):
return "a1:b2:c3:d4:e5"
self.stub_out('os_net_config.utils.interface_mac', test_interface_mac)
self.stub_out('os_net_config.common.interface_mac', test_interface_mac)
interface = objects.Interface('em1', primary=True)
ovs_extra = "br-set-external-id {name} bridge-id {name}"
@ -2219,7 +2219,7 @@ class TestIfcfgNetConfigApply(base.TestCase):
self.provider.apply()
route_table_data = utils.get_file_data(
route_table_data = common.get_file_data(
self.temp_route_table_file.name)
self.assertEqual(_RT_FULL, route_table_data)
@ -2250,9 +2250,9 @@ class TestIfcfgNetConfigApply(base.TestCase):
self.provider.apply()
ifcfg_data = utils.get_file_data(self.temp_ifcfg_file.name)
ifcfg_data = common.get_file_data(self.temp_ifcfg_file.name)
self.assertEqual(_V4_IFCFG, ifcfg_data)
route_data = utils.get_file_data(self.temp_route_file.name)
route_data = common.get_file_data(self.temp_route_file.name)
self.assertEqual(_ROUTES, route_data)
def test_sriov_pf_network_apply(self):
@ -2272,9 +2272,9 @@ class TestIfcfgNetConfigApply(base.TestCase):
self.provider.apply()
ifcfg_data = utils.get_file_data(self.temp_ifcfg_file.name)
ifcfg_data = common.get_file_data(self.temp_ifcfg_file.name)
self.assertEqual(_V4_SRIOV_PF_IFCFG, ifcfg_data)
route_data = utils.get_file_data(self.temp_route_file.name)
route_data = common.get_file_data(self.temp_route_file.name)
self.assertEqual(_ROUTES_PF, route_data)
def test_dhcp_ovs_bridge_network_apply(self):
@ -2285,11 +2285,11 @@ class TestIfcfgNetConfigApply(base.TestCase):
self.provider.add_bridge(bridge)
self.provider.apply()
ifcfg_data = utils.get_file_data(self.temp_ifcfg_file.name)
ifcfg_data = common.get_file_data(self.temp_ifcfg_file.name)
self.assertEqual(_OVS_INTERFACE, ifcfg_data)
bridge_data = utils.get_file_data(self.temp_bridge_file.name)
bridge_data = common.get_file_data(self.temp_bridge_file.name)
self.assertEqual(_OVS_BRIDGE_DHCP, bridge_data)
route_data = utils.get_file_data(self.temp_route_file.name)
route_data = common.get_file_data(self.temp_route_file.name)
self.assertEqual("", route_data)
def test_dhclient_stop_on_iface_activate(self):
@ -2620,7 +2620,7 @@ class TestIfcfgNetConfigApply(base.TestCase):
self.provider.add_vlan(vlan)
self.provider.apply()
ifcfg_data = utils.get_file_data(self.temp_ifcfg_file.name)
ifcfg_data = common.get_file_data(self.temp_ifcfg_file.name)
self.assertEqual(_VLAN_NO_IP, ifcfg_data)
def test_cleanup(self):

37
os_net_config/tests/test_objects.py
View File

@ -19,10 +19,9 @@ import os
import random
import yaml
from os_net_config import common
from os_net_config import objects
from os_net_config import sriov_config
from os_net_config.tests import base
from os_net_config import utils
class TestRoute(base.TestCase):
@ -413,7 +412,7 @@ class TestBridge(base.TestCase):
def setUp(self):
super(TestBridge, self).setUp()
rand = str(int(random.random() * 100000))
sriov_config._SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
common.SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
def stub_is_ovs_installed():
return True
@ -422,8 +421,8 @@ class TestBridge(base.TestCase):
def tearDown(self):
super(TestBridge, self).tearDown()
if os.path.isfile(sriov_config._SRIOV_CONFIG_FILE):
os.remove(sriov_config._SRIOV_CONFIG_FILE)
if os.path.isfile(common.SRIOV_CONFIG_FILE):
os.remove(common.SRIOV_CONFIG_FILE)
def test_from_json_dhcp(self):
data = """{
@ -484,7 +483,7 @@ class TestBridge(base.TestCase):
self.assertTrue(interface1.ovs_port)
self.assertEqual("br-foo", interface1.bridge_name)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertListEqual(vf_final, vf_map)
@ -549,7 +548,7 @@ class TestBridge(base.TestCase):
self.assertEqual("em2", interface2.device)
self.assertEqual("br-foo", bond.bridge_name)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertListEqual(vf_final, vf_map)
@ -612,7 +611,7 @@ class TestBridge(base.TestCase):
objects.object_from_json(json.loads(data))
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertListEqual(vf_final, vf_map)
@ -659,7 +658,7 @@ class TestBridge(base.TestCase):
self.assertTrue(interface1.ovs_port)
self.assertEqual("br-foo", interface1.bridge_name)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertListEqual(vf_final, vf_map)
@ -710,7 +709,7 @@ class TestBridge(base.TestCase):
self.assertFalse(dpdk_interface.ovs_port)
self.assertEqual("br-foo", dpdk_interface.bridge_name)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertListEqual(vf_final, vf_map)
@ -766,7 +765,7 @@ class TestBridge(base.TestCase):
self.assertFalse(dpdk_interface.ovs_port)
self.assertEqual("br-foo", dpdk_interface.bridge_name)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertListEqual(vf_final, vf_map)
@ -1159,7 +1158,7 @@ class TestLinuxBond(base.TestCase):
def setUp(self):
super(TestLinuxBond, self).setUp()
rand = str(int(random.random() * 100000))
sriov_config._SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
common.SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
def stub_is_ovs_installed():
return True
@ -1168,8 +1167,8 @@ class TestLinuxBond(base.TestCase):
def tearDown(self):
super(TestLinuxBond, self).tearDown()
if os.path.isfile(sriov_config._SRIOV_CONFIG_FILE):
os.remove(sriov_config._SRIOV_CONFIG_FILE)
if os.path.isfile(common.SRIOV_CONFIG_FILE):
os.remove(common.SRIOV_CONFIG_FILE)
def test_from_json_dhcp(self):
data = """{
@ -1288,7 +1287,7 @@ class TestLinuxBond(base.TestCase):
self.assertEqual("em1", interface1.device)
self.assertEqual("em2", interface2.device)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertListEqual(vf_final, vf_map)
@ -1350,7 +1349,7 @@ class TestLinuxBond(base.TestCase):
test_get_pci_address)
objects.object_from_json(json.loads(data))
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertListEqual(vf_final, vf_map)
@ -1752,7 +1751,8 @@ class TestNicMapping(base.TestCase):
mac_map = {'em1': '12:34:56:78:9a:bc',
'em2': '12:34:56:de:f0:12'}
return mac_map[name]
self.stub_out('os_net_config.utils.interface_mac', dummy_interface_mac)
self.stub_out('os_net_config.common.interface_mac',
dummy_interface_mac)
self._stub_active_nics(['em1', 'em2'])
self._stub_available_nics(['em1', 'em2'])
mapping = {'nic1': '12:34:56:de:f0:12', 'nic2': '12:34:56:78:9a:bc'}
@ -1765,7 +1765,8 @@ class TestNicMapping(base.TestCase):
'em2': '12:34:56:de:f0:12'}
return mac_map[name]
self.stub_out('os_net_config.utils.interface_mac', dummy_interface_mac)
self.stub_out('os_net_config.common.interface_mac',
dummy_interface_mac)
self._stub_active_nics(['em1', 'em2'])
self._stub_available_nics(['em1', 'em2'])
mapping = {'nic1': '12:34:56:de:f0:12', 'nic2': 'aa:bb:cc:dd:ee:ff'}

84
os_net_config/tests/test_sriov_config.py
View File

@ -47,15 +47,15 @@ class TestSriovConfig(base.TestCase):
'rules.d_70-tripleo-reset-sriov.rules'
sriov_config._ALLOCATE_VFS_FILE = '/tmp/' + rand + 'etc_sysconfig_'\
'allocate_vfs'
sriov_config._SRIOV_CONFIG_FILE = '/tmp/' + rand + 'sriov_config'\
'.yaml'
common.SRIOV_CONFIG_FILE = '/tmp/' + rand + 'sriov_config.yaml'
sriov_config._REP_LINK_NAME_FILE = '/tmp/' + rand + 'rep_link.sh'
def tearDown(self):
super(TestSriovConfig, self).tearDown()
if os.path.isfile(common._LOG_FILE):
os.remove(common._LOG_FILE)
if os.path.isfile(sriov_config._SRIOV_CONFIG_FILE):
os.remove(sriov_config._SRIOV_CONFIG_FILE)
if os.path.isfile(common.SRIOV_CONFIG_FILE):
os.remove(common.SRIOV_CONFIG_FILE)
if os.path.isfile(sriov_config._IFUP_LOCAL_FILE):
os.remove(sriov_config._IFUP_LOCAL_FILE)
shutil.rmtree(common.SYS_CLASS_NET)
@ -247,7 +247,7 @@ class TestSriovConfig(base.TestCase):
cleanup_puppet_config_stub)
def _wait_for_vf_creation_stub(pf_name, numvfs):
self._save_action('_wait_for_vf_creation_stub')
self._save_action('_wait_for_vf_creation')
return
self.stub_out('os_net_config.sriov_config._wait_for_vf_creation',
_wait_for_vf_creation_stub)
@ -278,6 +278,44 @@ class TestSriovConfig(base.TestCase):
self.stub_out('os_net_config.sriov_config.set_numvfs',
set_numvfs_stub)
def get_pf_pci_stub(name):
pci_address = {"p2p1": "0000:01:01.0",
"p2p2": "0000:01:02.0",
"p2p3": "0000:01:03.0"}
return pci_address[name]
self.stub_out('os_net_config.sriov_config.get_pf_pci',
get_pf_pci_stub)
def get_vdpa_vhost_devices_stub():
self._save_action('get_vdpa_vhost_devices')
return
self.stub_out('os_net_config.sriov_config.get_vdpa_vhost_devices',
get_vdpa_vhost_devices_stub)
def load_kmods_stub(mods):
return
self.stub_out('os_net_config.sriov_config.load_kmods',
load_kmods_stub)
def modprobe_stub(*args):
out = """vdpa x
vhost_vdpa x
"""
return out, "hello"
self.stub_out('oslo_concurrency.processutils.execute',
modprobe_stub)
def reload_udev_rules_stub():
self._save_action('reload_udev_rules')
return
self.stub_out('os_net_config.sriov_config.reload_udev_rules',
reload_udev_rules_stub)
def test_list_kmods(self):
self.setUp_pf_stubs()
self.assertEqual([], common.list_kmods(["vhost_vdpa", "vdpa"]))
self.assertEqual(["test"], common.list_kmods(["test", "vdpa"]))
def test_configure_sriov_pf(self):
"""Test the numvfs setting for SR-IOV PF
@ -295,12 +333,12 @@ class TestSriovConfig(base.TestCase):
'reload_udev_rules',
'set_numvfs',
'get_numvfs',
'_wait_for_vf_creation_stub',
'_wait_for_vf_creation',
'get_numvfs',
'reload_udev_rules',
'set_numvfs',
'get_numvfs',
'_wait_for_vf_creation_stub',
'_wait_for_vf_creation',
'get_numvfs',
'udev_monitor_stop',
]
@ -314,7 +352,7 @@ class TestSriovConfig(base.TestCase):
self._write_numvfs(ifname)
self._action_order = []
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, pf_config)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, pf_config)
sriov_config.configure_sriov_pf()
self.assertEqual(exp_actions, self._action_order)
f = open(sriov_config._UDEV_LEGACY_RULE_FILE, 'r')
@ -337,12 +375,12 @@ class TestSriovConfig(base.TestCase):
'udev_monitor_start',
'set_numvfs',
'get_numvfs',
'_wait_for_vf_creation_stub',
'_wait_for_vf_creation',
'get_numvfs',
'reload_udev_rules',
'set_numvfs',
'get_numvfs',
'_wait_for_vf_creation_stub',
'_wait_for_vf_creation',
'get_numvfs',
'udev_monitor_stop',
]
@ -360,7 +398,7 @@ class TestSriovConfig(base.TestCase):
self._write_numvfs(ifname)
self._action_order = []
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, pf_config)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, pf_config)
sriov_config.configure_sriov_pf()
self.assertEqual(exp_actions, self._action_order)
f = open(sriov_config._UDEV_LEGACY_RULE_FILE, 'r')
@ -384,12 +422,12 @@ class TestSriovConfig(base.TestCase):
'reload_udev_rules',
'set_numvfs',
'get_numvfs',
'_wait_for_vf_creation_stub',
'_wait_for_vf_creation',
'get_numvfs',
'reload_udev_rules',
'set_numvfs',
'get_numvfs',
'_wait_for_vf_creation_stub',
'_wait_for_vf_creation',
'get_numvfs',
'udev_monitor_stop',
]
@ -407,7 +445,7 @@ class TestSriovConfig(base.TestCase):
self._write_numvfs(ifname)
self._action_order = []
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, pf_config)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, pf_config)
sriov_config.configure_sriov_pf()
self.assertEqual(exp_actions, self._action_order)
f = open(sriov_config._UDEV_LEGACY_RULE_FILE, 'r')
@ -425,18 +463,28 @@ class TestSriovConfig(base.TestCase):
exp_actions = [
'udev_monitor_setup',
'udev_monitor_start',
'get_vdpa_vhost_devices',
'configure_switchdev',
'set_numvfs',
'get_numvfs',
'_wait_for_vf_creation_stub',
'_wait_for_vf_creation',
'get_numvfs',
'reload_udev_rules',
'reload_udev_rules',
'reload_udev_rules',
'reload_udev_rules',
'configure_switchdev',
'set_numvfs',
'get_numvfs',
'_wait_for_vf_creation_stub',
'_wait_for_vf_creation',
'get_numvfs',
'reload_udev_rules',
'reload_udev_rules',
'reload_udev_rules',
'trigger_udev_rules',
'udev_monitor_stop',
]
pf_config = [{"device_type": "pf", "name": "p2p1", "numvfs": 10,
"vdpa": True, "link_mode": "switchdev"},
{"device_type": "pf", "name": "p2p2", "numvfs": 12,
@ -446,7 +494,7 @@ class TestSriovConfig(base.TestCase):
self._write_numvfs(ifname)
self._action_order = []
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, pf_config)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, pf_config)
sriov_config.configure_sriov_pf()
self.assertEqual(exp_actions, self._action_order)
self.assertEqual(10, sriov_config.get_numvfs('p2p1'))
@ -565,7 +613,7 @@ class TestSriovConfig(base.TestCase):
self.stub_out('os_net_config.sriov_config.run_ip_config_cmd',
run_ip_config_cmd_stub)
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, vf_config)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, vf_config)
sriov_config.configure_sriov_vf()
for cmd in exp_cmds:

65
os_net_config/tests/test_utils.py
View File

@ -88,16 +88,19 @@ class TestUtils(base.TestCase):
def setUp(self):
super(TestUtils, self).setUp()
rand = str(int(random.random() * 100000))
utils._DPDK_MAPPING_FILE = '/tmp/dpdk_mapping_' + rand + '.yaml'
sriov_config._SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
common.DPDK_MAPPING_FILE = '/tmp/dpdk_mapping_' + rand + '.yaml'
common.SRIOV_CONFIG_FILE = '/tmp/sriov_config_' + rand + '.yaml'
common._LOG_FILE = '/tmp/' + rand + 'os_net_config.log'
sriov_config._UDEV_LEGACY_RULE_FILE = UDEV_FILE + rand
def tearDown(self):
super(TestUtils, self).tearDown()
if os.path.isfile(utils._DPDK_MAPPING_FILE):
os.remove(utils._DPDK_MAPPING_FILE)
if os.path.isfile(sriov_config._SRIOV_CONFIG_FILE):
os.remove(sriov_config._SRIOV_CONFIG_FILE)
if os.path.isfile(common.DPDK_MAPPING_FILE):
os.remove(common.DPDK_MAPPING_FILE)
if os.path.isfile(common._LOG_FILE):
os.remove(common._LOG_FILE)
if os.path.isfile(common.SRIOV_CONFIG_FILE):
os.remove(common.SRIOV_CONFIG_FILE)
if os.path.isfile(sriov_config._UDEV_LEGACY_RULE_FILE):
os.remove(sriov_config._UDEV_LEGACY_RULE_FILE)
@ -134,7 +137,7 @@ class TestUtils(base.TestCase):
self.stub_out('os_net_config.sriov_config.get_numvfs',
get_numvfs_stub)
utils.update_sriov_pf_map('eth1', 10, False)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_pf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(sriov_pf_map))
test_sriov_pf_map = [{'device_type': 'pf', 'link_mode': 'legacy',
@ -147,7 +150,7 @@ class TestUtils(base.TestCase):
self.stub_out('os_net_config.sriov_config.get_numvfs',
get_numvfs_stub)
utils.update_sriov_pf_map('eth1', 10, False)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_pf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(sriov_pf_map))
test_sriov_pf_map = [{'device_type': 'pf', 'link_mode': 'legacy',
@ -168,7 +171,7 @@ class TestUtils(base.TestCase):
self.stub_out('os_net_config.sriov_config.get_numvfs',
get_numvfs_stub)
utils.update_sriov_pf_map('eth1', 10, False, promisc='off')
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_pf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(sriov_pf_map))
test_sriov_pf_map = [{'device_type': 'pf', 'link_mode': 'legacy',
@ -182,7 +185,7 @@ class TestUtils(base.TestCase):
self.stub_out('os_net_config.sriov_config.get_numvfs',
get_numvfs_stub)
utils.update_sriov_pf_map('eth1', 10, False, vdpa=True)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_pf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(sriov_pf_map))
test_sriov_pf_map = [{'device_type': 'pf', 'link_mode': 'legacy',
@ -196,7 +199,7 @@ class TestUtils(base.TestCase):
get_numvfs_stub)
pf_initial = [{'device_type': 'pf', 'link_mode': 'legacy',
'name': 'eth1', 'numvfs': 10}]
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, pf_initial)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, pf_initial)
self.assertRaises(sriov_config.SRIOVNumvfsException,
utils.update_sriov_pf_map, 'eth1', 20, False)
@ -208,13 +211,13 @@ class TestUtils(base.TestCase):
pf_initial = [{'device_type': 'pf', 'link_mode': 'legacy',
'name': 'eth1', 'numvfs': 10, 'promisc': 'on',
'vdpa': False}]
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, pf_initial)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, pf_initial)
utils.update_sriov_pf_map('eth1', 10, False, promisc='off')
pf_final = [{'device_type': 'pf', 'link_mode': 'legacy',
'name': 'eth1', 'numvfs': 10, 'promisc': 'off',
'vdpa': False}]
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
pf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(pf_map))
@ -228,13 +231,13 @@ class TestUtils(base.TestCase):
pf_initial = [{'device_type': 'pf', 'link_mode': 'legacy',
'name': 'eth1', 'numvfs': 10, 'promisc': 'on',
'vdpa': False}]
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, pf_initial)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, pf_initial)
utils.update_sriov_pf_map('eth1', 10, False, vdpa=True)
pf_final = [{'device_type': 'pf', 'link_mode': 'legacy',
'name': 'eth1', 'numvfs': 10, 'promisc': 'on',
'vdpa': True}]
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
pf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(pf_map))
@ -242,7 +245,7 @@ class TestUtils(base.TestCase):
def test_update_sriov_vf_map_minimal_new(self):
utils.update_sriov_vf_map('eth1', 2, 'eth1_2')
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_vf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(sriov_vf_map))
test_sriov_vf_map = [{'device_type': 'vf', 'name': 'eth1_2',
@ -258,7 +261,7 @@ class TestUtils(base.TestCase):
utils.update_sriov_pf_map('eth1', 10, False)
utils.update_sriov_pf_map('eth2', 10, False)
utils.update_sriov_vf_map('eth1', 2, 'eth1_2')
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_vf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(3, len(sriov_vf_map))
@ -286,7 +289,7 @@ class TestUtils(base.TestCase):
spoofcheck="on", trust="on", state="enable",
macaddr="AA:BB:CC:DD:EE:FF", promisc="off",
pci_address="0000:80:00.1", max_tx_rate=10)
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
sriov_vf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(sriov_vf_map))
test_sriov_vf_map = [{'device_type': 'vf', 'name': 'eth1_2',
@ -303,7 +306,7 @@ class TestUtils(base.TestCase):
def test_update_sriov_vf_map_exist(self):
vf_initial = [{'device_type': 'vf', 'name': 'eth1_2',
'device': {"name": "eth1", "vfid": 2}}]
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, vf_initial)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, vf_initial)
utils.update_sriov_vf_map('eth1', 2, 'eth1_2', vlan_id=10, qos=5,
spoofcheck="on", trust="on", state="enable",
@ -318,7 +321,7 @@ class TestUtils(base.TestCase):
'macaddr': 'AA:BB:CC:DD:EE:FF',
'promisc': 'off',
'pci_address': '0000:80:00.1'}]
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(vf_map))
@ -334,7 +337,7 @@ class TestUtils(base.TestCase):
'macaddr': 'AA:BB:CC:DD:EE:FF',
'promisc': 'off',
'pci_address': "0000:80:00.1"}]
utils.write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, vf_initial)
utils.write_yaml_config(common.SRIOV_CONFIG_FILE, vf_initial)
utils.update_sriov_vf_map('eth1', 2, 'eth1_2', vlan_id=100, qos=15,
spoofcheck="off", trust="off", state="auto",
@ -349,7 +352,7 @@ class TestUtils(base.TestCase):
'macaddr': 'BB:BB:CC:DD:EE:FF',
'promisc': 'on',
'pci_address': '0000:80:00.1'}]
contents = utils.get_file_data(sriov_config._SRIOV_CONFIG_FILE)
contents = common.get_file_data(common.SRIOV_CONFIG_FILE)
vf_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(vf_map))
@ -485,7 +488,7 @@ class TestUtils(base.TestCase):
def test_get_dpdk_mac_address(name):
return '01:02:03:04:05:06'
self.stub_out('oslo_concurrency.processutils.execute', test_execute)
self.stub_out('os_net_config.utils._get_dpdk_mac_address',
self.stub_out('os_net_config.common._get_dpdk_mac_address',
test_get_dpdk_mac_address)
try:
utils.bind_dpdk_interfaces('nic2', 'vfio-pci', False)
@ -503,7 +506,7 @@ class TestUtils(base.TestCase):
def test_get_dpdk_mac_address(name):
return '01:02:03:04:05:06'
self.stub_out('oslo_concurrency.processutils.execute', test_execute)
self.stub_out('os_net_config.utils._get_dpdk_mac_address',
self.stub_out('os_net_config.common._get_dpdk_mac_address',
test_get_dpdk_mac_address)
self.assertRaises(utils.OvsDpdkBindException,
@ -593,7 +596,7 @@ class TestUtils(base.TestCase):
def test__update_dpdk_map_new(self):
utils._update_dpdk_map('eth1', '0000:03:00.0', '01:02:03:04:05:06',
'vfio-pci')
contents = utils.get_file_data(utils._DPDK_MAPPING_FILE)
contents = common.get_file_data(common.DPDK_MAPPING_FILE)
dpdk_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(dpdk_map))
@ -606,11 +609,11 @@ class TestUtils(base.TestCase):
dpdk_test = [{'name': 'eth1', 'pci_address': '0000:03:00.0',
'mac_address': '01:02:03:04:05:06',
'driver': 'vfio-pci'}]
utils.write_yaml_config(utils._DPDK_MAPPING_FILE, dpdk_test)
utils.write_yaml_config(common.DPDK_MAPPING_FILE, dpdk_test)
utils._update_dpdk_map('eth1', '0000:03:00.0', '01:02:03:04:05:06',
'vfio-pci')
contents = utils.get_file_data(utils._DPDK_MAPPING_FILE)
contents = common.get_file_data(common.DPDK_MAPPING_FILE)
dpdk_map = yaml.safe_load(contents) if contents else []
self.assertEqual(1, len(dpdk_map))
@ -619,7 +622,7 @@ class TestUtils(base.TestCase):
def test_update_dpdk_map_value_change(self):
dpdk_test = [{'name': 'eth1', 'pci_address': '0000:03:00.0',
'driver': 'vfio-pci'}]
utils.write_yaml_config(utils._DPDK_MAPPING_FILE, dpdk_test)
utils.write_yaml_config(common.DPDK_MAPPING_FILE, dpdk_test)
dpdk_test = [{'name': 'eth1', 'pci_address': '0000:03:00.0',
'mac_address': '01:02:03:04:05:06',
@ -627,7 +630,7 @@ class TestUtils(base.TestCase):
utils._update_dpdk_map('eth1', '0000:03:00.0', '01:02:03:04:05:06',
'vfio-pci')
try:
contents = utils.get_file_data(utils._DPDK_MAPPING_FILE)
contents = common.get_file_data(common.DPDK_MAPPING_FILE)
except IOError:
pass
@ -702,7 +705,7 @@ class TestUtils(base.TestCase):
shutil.rmtree(tmp_pci_dir)
def test_interface_mac_raises(self):
self.assertRaises(IOError, utils.interface_mac, 'ens20f2p3')
self.assertRaises(IOError, common.interface_mac, 'ens20f2p3')
def test_get_dpdk_devargs_mlnx(self):
def test_execute(name, dummy1, dummy2=None, dummy3=None):
@ -933,7 +936,7 @@ dpdk {
utils.update_vpp_mapping(interfaces, [])
contents = utils.get_file_data(utils._DPDK_MAPPING_FILE)
contents = common.get_file_data(common.DPDK_MAPPING_FILE)
dpdk_test = [{'name': 'eth1', 'pci_address': '0000:00:09.0',
'mac_address': '01:02:03:04:05:06',

94
os_net_config/utils.py
View File

@ -27,15 +27,6 @@ from oslo_concurrency import processutils
logger = logging.getLogger(__name__)
_SYS_BUS_PCI_DEV = '/sys/bus/pci/devices'
# File to contain the DPDK mapped nics, as nic name will not be available after
# binding driver, which is required for correct nic numbering.
# Format of the file (list mapped nic's details):
# -
# name: eth1
# pci_address: 0000:02:00.0
# mac_address: 01:02:03:04:05:06
# driver: vfio-pci
_DPDK_MAPPING_FILE = '/var/lib/os-net-config/dpdk_mapping.yaml'
# sriov_config service shall be created and enabled so that the various
# SR-IOV PF and VF configurations shall be done during reboot as well using
# sriov_config.py installed in path /usr/bin/os-net-config-sriov
@ -95,40 +86,6 @@ def ensure_directory_presence(filepath):
os.makedirs(dir_path)
def get_file_data(filename):
if not os.path.exists(filename):
return ''
try:
with open(filename, 'r') as f:
return f.read()
except IOError:
logger.error("Error reading file: %s" % filename)
return ''
def interface_mac(name):
try: # If the iface is part of a Linux bond, the real MAC is only here.
with open(common.get_dev_path(name, 'bonding_slave/perm_hwaddr'),
'r') as f:
return f.read().rstrip()
except IOError:
pass # Iface is not part of a bond, continue
try:
with open(common.get_dev_path(name, '_address'), 'r') as f:
return f.read().rstrip()
except IOError:
# If the interface is bound to a DPDK driver, get the mac address from
# the DPDK mapping file as /sys files will be removed after binding.
dpdk_mac_address = _get_dpdk_mac_address(name)
if dpdk_mac_address:
return dpdk_mac_address
logger.error("Unable to read mac address: %s" % name)
raise
def is_active_nic(interface_name):
return _is_available_nic(interface_name, True)
@ -170,7 +127,7 @@ def _is_vf_by_name(interface_name, check_mapping_file=False):
vf_path_check = common.get_dev_path(interface_name, 'physfn')
is_sriov_vf = os.path.isdir(vf_path_check)
if not is_sriov_vf and check_mapping_file:
sriov_map = _get_sriov_map()
sriov_map = common.get_sriov_map()
for item in sriov_map:
if (item['name'] == interface_name and
item['device_type'] == 'vf'):
@ -246,7 +203,7 @@ def _ordered_nics(check_active):
# Adding nics which are bound to DPDK as it will not be found in '/sys'
# after it is bound to DPDK driver.
contents = get_file_data(_DPDK_MAPPING_FILE)
contents = common.get_file_data(common.DPDK_MAPPING_FILE)
if contents:
dpdk_map = yaml.safe_load(contents)
for item in dpdk_map:
@ -267,7 +224,7 @@ def _ordered_nics(check_active):
nics.append(nic)
else:
logger.info("No DPDK mapping available in path (%s)" %
_DPDK_MAPPING_FILE)
common.DPDK_MAPPING_FILE)
# NOTE: we could just natural sort all active devices,
# but this ensures em, eno, and eth are ordered first
@ -279,7 +236,7 @@ def _ordered_nics(check_active):
def diff(filename, data):
file_data = get_file_data(filename)
file_data = common.get_file_data(filename)
logger.debug("Diff file data:\n%s" % file_data)
logger.debug("Diff data:\n%s" % data)
# convert to string as JSON may have unicode in it
@ -309,7 +266,7 @@ def bind_dpdk_interfaces(ifname, driver, noop):
msg = "Failed to modprobe vfio-pci module"
raise OvsDpdkBindException(msg)
mac_address = interface_mac(ifname)
mac_address = common.interface_mac(ifname)
vendor_id = common.get_vendor_id(ifname)
try:
out, err = processutils.execute('driverctl', 'set-override',
@ -383,7 +340,7 @@ def translate_ifname_to_pci_address(ifname, noop):
pci_address = get_stored_pci_address(ifname, noop)
if pci_address is None and not noop:
pci_address = get_pci_address(ifname, noop=False)
mac_address = interface_mac(ifname)
mac_address = common.interface_mac(ifname)
_update_dpdk_map(ifname, pci_address, mac_address, driver=None)
return pci_address
@ -413,7 +370,7 @@ def get_dpdk_devargs(ifname, noop):
# address associated with multiple ports. Using a PCI
# device won’t work. Instead, we should use
# "class=eth,mac=<MAC>"
dpdk_devargs = "class=eth,mac=%s" % interface_mac(ifname)
dpdk_devargs = f"class=eth,mac={common.interface_mac(ifname)}"
elif is_active_nic(ifname):
# Other Mellanox devices are active and they are not stored
# in dpdk_mapping.yaml file, so we need to get their pci
@ -436,7 +393,7 @@ def get_dpdk_devargs(ifname, noop):
# Once the interface is bound to a DPDK driver, all the references to the
# interface including '/sys' and '/proc', will be removed. And there is no
# way to identify the nic name after it is bound. So, the DPDK bound nic info
# is stored persistently in _DPDK_MAPPING_FILE and is used to for nic numbering
# is stored persistently in DPDK_MAPPING_FILE and is used to for nic numbering
# on subsequent runs of os-net-config.
def _update_dpdk_map(ifname, pci_address, mac_address, driver):
dpdk_map = _get_dpdk_map()
@ -454,23 +411,15 @@ def _update_dpdk_map(ifname, pci_address, mac_address, driver):
new_item['driver'] = driver
dpdk_map.append(new_item)
write_yaml_config(_DPDK_MAPPING_FILE, dpdk_map)
write_yaml_config(common.DPDK_MAPPING_FILE, dpdk_map)
def _get_dpdk_map():
contents = get_file_data(_DPDK_MAPPING_FILE)
contents = common.get_file_data(common.DPDK_MAPPING_FILE)
dpdk_map = yaml.safe_load(contents) if contents else []
return dpdk_map
def _get_dpdk_mac_address(name):
contents = get_file_data(_DPDK_MAPPING_FILE)
dpdk_map = yaml.safe_load(contents) if contents else []
for item in dpdk_map:
if item['name'] == name:
return item['mac_address']
def update_sriov_pf_map(ifname, numvfs, noop, promisc=None,
link_mode='legacy', vdpa=False):
if not noop:
@ -478,7 +427,7 @@ def update_sriov_pf_map(ifname, numvfs, noop, promisc=None,
if cur_numvfs > 0 and cur_numvfs != numvfs:
msg = ("Can't change the numvfs for %s" % ifname)
raise sriov_config.SRIOVNumvfsException(msg)
sriov_map = _get_sriov_map()
sriov_map = common.get_sriov_map()
for item in sriov_map:
if item['device_type'] == 'pf' and item['name'] == ifname:
item['numvfs'] = numvfs
@ -498,13 +447,7 @@ def update_sriov_pf_map(ifname, numvfs, noop, promisc=None,
new_item['link_mode'] = link_mode
sriov_map.append(new_item)
write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, sriov_map)
def _get_sriov_map():
contents = get_file_data(sriov_config._SRIOV_CONFIG_FILE)
sriov_map = yaml.safe_load(contents) if contents else []
return sriov_map
write_yaml_config(common.SRIOV_CONFIG_FILE, sriov_map)
def _set_vf_fields(vf_name, vlan_id, qos, spoofcheck, trust, state, macaddr,
@ -540,7 +483,7 @@ def update_sriov_vf_map(pf_name, vfid, vf_name, vlan_id=0, qos=0,
spoofcheck=None, trust=None, state=None, macaddr=None,
promisc=None, pci_address=None,
min_tx_rate=0, max_tx_rate=0):
sriov_map = _get_sriov_map()
sriov_map = common.get_sriov_map()
for item in sriov_map:
if (item['device_type'] == 'vf' and
item['device'].get('name') == pf_name and
@ -560,11 +503,11 @@ def update_sriov_vf_map(pf_name, vfid, vf_name, vlan_id=0, qos=0,
_clear_empty_values(new_item)
sriov_map.append(new_item)
write_yaml_config(sriov_config._SRIOV_CONFIG_FILE, sriov_map)
write_yaml_config(common.SRIOV_CONFIG_FILE, sriov_map)
def _get_vf_name_from_map(pf_name, vfid):
sriov_map = _get_sriov_map()
sriov_map = common.get_sriov_map()
for item in sriov_map:
if (item['device_type'] == 'vf' and
item['device'].get('name') == pf_name and
@ -623,8 +566,7 @@ def configure_sriov_vfs():
def get_vf_devname(pf_name, vfid):
vf_path = os.path.join(common.SYS_CLASS_NET, pf_name,
f"device/virtfn{vfid}/net")
vf_path = common.get_dev_path(pf_name, f"virtfn{vfid}/net")
if os.path.isdir(vf_path):
vf_nic = os.listdir(vf_path)
else:
@ -754,7 +696,7 @@ def generate_vpp_config(vpp_config_path, vpp_interfaces, vpp_bonds):
:return: updated VPP config content.
"""
data = get_file_data(vpp_config_path)
data = common.get_file_data(vpp_config_path)
# Add interface config to 'dpdk' section
for vpp_interface in vpp_interfaces:
@ -911,7 +853,7 @@ def update_vpp_mapping(vpp_interfaces, vpp_bonds):
else:
raise VppException('Bond %s not found in VPP.' % vpp_bond.name)
vpp_start_cli = get_file_data(_VPP_EXEC_FILE)
vpp_start_cli = common.get_file_data(_VPP_EXEC_FILE)
for cli_line in cli_list:
if not re.search(r'^\s*%s\s*$' % cli_line,
vpp_start_cli, re.MULTILINE):