744 lines
33 KiB
YAML
744 lines
33 KiB
YAML
heat_template_version: wallaby
|
|
|
|
description: >
|
|
This's a temporary workaround for upgrading Nvidia mellanox NICs
|
|
FW and configuring them using mstflint tool
|
|
|
|
parameters:
|
|
BIN_DIR_URL:
|
|
type: string
|
|
default: ''
|
|
description: 'URL of a directory containing Mellanox NIC Firmware'
|
|
FORCE_UPDATE:
|
|
type: boolean
|
|
default: False
|
|
description: "Force update the fw even if it's an older version"
|
|
DEV_WHITE_LIST:
|
|
type: comma_delimited_list
|
|
default: []
|
|
description: list of MLNX devices PCIs to be processed.
|
|
If the value is empty, all MLNX devices will be processed.
|
|
Example, ['0000:04:00.0', '0000:81:00.0']
|
|
Make sure to choose only the PCI ends with 0
|
|
NUM_OF_VFS:
|
|
type: number
|
|
default: 32
|
|
description: 'Max number of vfs'
|
|
SRIOV_EN:
|
|
type: boolean
|
|
default: True
|
|
description: 'Enable/Disable Sriov'
|
|
LINK_TYPE:
|
|
type: string
|
|
default: 'eth'
|
|
description: 'Link type ["eth", "ib"]'
|
|
ESWITCH_IPV4_TTL_MODIFY_ENABLE:
|
|
type: boolean
|
|
default: False
|
|
description: 'Enable TTL modification by E-Switch'
|
|
PRIO_TAG_REQUIRED_EN:
|
|
type: boolean
|
|
default: False
|
|
description: 'Priority tag required'
|
|
ESWITCH_HAIRPIN_TOT_BUFFER_SIZE:
|
|
type: json
|
|
default: {"*": "17"}
|
|
description: >
|
|
If a single key of "*" is provided, then its value will set to all indexes.
|
|
If you need to set configuration for a set of specific indexes, you can pass the
|
|
value as below for index 2 to be 17 and index 3 to be 16
|
|
Example, {"2": "17", "3": "16"}
|
|
Make sure to choose only the PCI ends with 0
|
|
ESWITCH_HAIRPIN_DESCRIPTORS:
|
|
type: json
|
|
default: {"*": "11"}
|
|
description: >
|
|
If a single key of "*" is provided, then its value will set to all indexes.
|
|
If you need to set configuration for a set of specific indexes, you can pass the
|
|
value as below for index 2 to be 17 and index 3 to be 16
|
|
Example, {"2": "17", "3": "16"}
|
|
Make sure to choose only the PCI ends with 0
|
|
BF_NIC_MODE:
|
|
type: boolean
|
|
default: False
|
|
description: >
|
|
A special parameter for BlueField SmartNICs, if the value is False, that means the
|
|
NIC in smart nic mode and it's going to set the following config:
|
|
"INTERNAL_CPU_PAGE_SUPPLIER": "ECPF",
|
|
"INTERNAL_CPU_ESWITCH_MANAGER": "ECPF",
|
|
"INTERNAL_CPU_IB_VPORT0": "ECPF",
|
|
"INTERNAL_CPU_OFFLOAD_ENGINE": "ENABLED",
|
|
If the value is True, that means the NIC in nic mode and it's going
|
|
to set the following config:
|
|
"INTERNAL_CPU_PAGE_SUPPLIER", "EXT_HOST_PF"
|
|
"INTERNAL_CPU_ESWITCH_MANAGER", "EXT_HOST_PF"
|
|
"INTERNAL_CPU_IB_VPORT0", "EXT_HOST_PF"
|
|
"INTERNAL_CPU_OFFLOAD_ENGINE", "DISABLED"
|
|
RESET_SYNC:
|
|
type: number
|
|
default: 0
|
|
description: >
|
|
Run mstfwreset with the specified reset-sync [0,1],
|
|
The default and Current supported option now is 0
|
|
|
|
|
|
resources:
|
|
userdata:
|
|
type: OS::Heat::MultipartMime
|
|
properties:
|
|
parts:
|
|
- config: {get_resource: nvidia_nic_fw_update}
|
|
|
|
nvidia_nic_fw_update:
|
|
type: OS::Heat::SoftwareConfig
|
|
properties:
|
|
config:
|
|
str_replace:
|
|
template: |
|
|
#!/usr/bin/env python
|
|
|
|
import logging
|
|
import os
|
|
import re
|
|
import shutil
|
|
import tempfile
|
|
import threading
|
|
|
|
import six
|
|
from six.moves import html_parser
|
|
from six.moves.urllib import error as urlError
|
|
from six.moves.urllib import request as urlRequest
|
|
|
|
from oslo_concurrency import processutils
|
|
|
|
FW_VERSION_REGEX = r'FW Version:\s*\t*(?P<fw_ver>\d+\.\d+\.\d+)'
|
|
RUNNING_FW_VERSION_REGEX = r'FW Version\(Running\):\s*\t*(?P<fw_ver>\d+\.\d+\.\d+)'
|
|
PSID_REGEX = r'PSID:\s*\t*(?P<psid>\w+)'
|
|
ARRAY_VALUE_REGEX = r'Array\[(?P<first_index>\d+)\.\.(?P<last_index>\d+)\]'
|
|
ARRAY_PARAM_REGEX = r'(?P<param_name>\w+)\[\d+\]'
|
|
|
|
_DEV_WHITE_LIST = $DEV_WHITE_LIST
|
|
_FORCE_UPDATE = $FORCE_UPDATE
|
|
_BIN_DIR_URL = "$BIN_DIR_URL"
|
|
_BF_NIC_MODE = "$BF_NIC_MODE"
|
|
# TODO(adrianc): add configurable parameter for logging
|
|
logging.basicConfig(
|
|
filename='/var/log/nvidia_nic_fw_update.log',
|
|
filemode='w',
|
|
level=logging.DEBUG)
|
|
LOG = logging.getLogger("nvidia_nic_fw_update")
|
|
|
|
_MLX_CONFIG = {
|
|
"SRIOV_EN": "$SRIOV_EN",
|
|
"NUM_OF_VFS": "$NUM_OF_VFS",
|
|
"LINK_TYPE_P1": "$LINK_TYPE",
|
|
"LINK_TYPE_P2": "$LINK_TYPE",
|
|
"ESWITCH_IPV4_TTL_MODIFY_ENABLE": "$ESWITCH_IPV4_TTL_MODIFY_ENABLE",
|
|
"PRIO_TAG_REQUIRED_EN": "$PRIO_TAG_REQUIRED_EN",
|
|
"ESWITCH_HAIRPIN_TOT_BUFFER_SIZE": $ESWITCH_HAIRPIN_TOT_BUFFER_SIZE,
|
|
"ESWITCH_HAIRPIN_DESCRIPTORS": $ESWITCH_HAIRPIN_DESCRIPTORS
|
|
}
|
|
if _BF_NIC_MODE.lower() == "false":
|
|
# It means we are in smart nic mode for BlueField device
|
|
_MLX_CONFIG["INTERNAL_CPU_PAGE_SUPPLIER"] = "ECPF"
|
|
_MLX_CONFIG["INTERNAL_CPU_ESWITCH_MANAGER"] = "ECPF"
|
|
_MLX_CONFIG["INTERNAL_CPU_IB_VPORT0"] = "ECPF"
|
|
_MLX_CONFIG["INTERNAL_CPU_OFFLOAD_ENGINE"] = "ENABLED"
|
|
_MLX_CONFIG["INTERNAL_CPU_RSHIM"] = "True"
|
|
else:
|
|
# It measn we are in nic mode for BlueField device
|
|
_MLX_CONFIG["INTERNAL_CPU_PAGE_SUPPLIER"] = "EXT_HOST_PF"
|
|
_MLX_CONFIG["INTERNAL_CPU_ESWITCH_MANAGER"] = "EXT_HOST_PF"
|
|
_MLX_CONFIG["INTERNAL_CPU_IB_VPORT0"] = "EXT_HOST_PF"
|
|
_MLX_CONFIG["INTERNAL_CPU_OFFLOAD_ENGINE"] = "DISABLED"
|
|
|
|
_RESET_SYNC = $RESET_SYNC
|
|
|
|
def run_command(*cmd, **kwargs):
|
|
try:
|
|
out, err = processutils.execute(*cmd, **kwargs)
|
|
except processutils.ProcessExecutionError as e:
|
|
LOG.error("Failed to execute %s, %s", ' '.join(cmd), str(e))
|
|
raise e
|
|
if err:
|
|
LOG.warning("Got stderr output: %s" % err)
|
|
LOG.debug(out)
|
|
return out
|
|
|
|
|
|
def parse_mstflint_query_output(out):
|
|
""" Parse Mstflint query output
|
|
|
|
For now just extract 'FW Version' and 'PSID'
|
|
|
|
:param out: mstflint query output
|
|
:return: dictionary of query attributes
|
|
"""
|
|
query_info = {}
|
|
for line in out.split('\n'):
|
|
fw_ver = re.match(FW_VERSION_REGEX, line)
|
|
psid = re.match(PSID_REGEX, line)
|
|
running_fw_ver = re.match(RUNNING_FW_VERSION_REGEX, line)
|
|
if fw_ver:
|
|
query_info["fw_ver"] = fw_ver.group('fw_ver')
|
|
if running_fw_ver:
|
|
query_info["running_fw_ver"] = running_fw_ver.group('fw_ver')
|
|
if psid:
|
|
query_info["psid"] = psid.group('psid')
|
|
return query_info
|
|
|
|
|
|
class MlnxDevices(object):
|
|
""" Discover and retrieve Mellanox PCI devices.
|
|
|
|
Can be used as an iterator once discover has been called.
|
|
"""
|
|
|
|
def __init__(self, dev_white_list):
|
|
self._devs = []
|
|
self._dev_white_list = dev_white_list
|
|
|
|
def discover(self):
|
|
""" Discover Mellanox devices in the system. (first PF of every device)
|
|
|
|
:return: None
|
|
"""
|
|
if self._devs:
|
|
return self._devs
|
|
|
|
devs = []
|
|
cmd = ['lspci', '-D', '-d', '15b3:']
|
|
out = run_command(*cmd)
|
|
for line in out.split('\n'):
|
|
if not line:
|
|
continue
|
|
dev = line.split()[0]
|
|
if dev.endswith('.0') and (not self._dev_white_list or
|
|
dev in self._dev_white_list):
|
|
devs.append(dev)
|
|
self._devs = devs
|
|
LOG.info("Found Mellanox devices: %s", devs)
|
|
other_devs = set(self._dev_white_list) - set(devs)
|
|
if other_devs:
|
|
LOG.warning("Not all devices in PCI white list where discovered,"
|
|
" %s these may not be nvidia devices or have their "
|
|
"PCI function set to non zero." % other_devs)
|
|
|
|
def __len__(self):
|
|
return len(self._devs)
|
|
|
|
def __iter__(self):
|
|
return self._devs.__iter__()
|
|
|
|
|
|
class MlnxConfigParamMetaData(object):
|
|
""" Metadata about a single mlxconfig parameter"""
|
|
|
|
def __init__(self, name):
|
|
self.name = name
|
|
|
|
class MlnxConfigArrayParamMetaData(MlnxConfigParamMetaData):
|
|
""" Metadata about a single mlxconfig array parameter"""
|
|
|
|
def __init__(self, name, first_idx, last_idx):
|
|
super(MlnxConfigArrayParamMetaData, self).__init__(name)
|
|
self.first_index = int(first_idx)
|
|
self.last_index = int(last_idx)
|
|
|
|
|
|
class MlnxDeviceConfig(object):
|
|
""" Get/Set Mellanox Device configurations
|
|
"""
|
|
|
|
def __init__(self, pci_dev):
|
|
self.pci_dev = pci_dev
|
|
self._tool_confs = None
|
|
# NOTE(adrianc) ATM contains only array type parameter metadata
|
|
self.mlnx_config_array_param_metadata = {}
|
|
|
|
def _mstconfig_parse_data(self, data):
|
|
# Parsing the mstconfig out to json
|
|
data = list(filter(None, data.split('\n')))
|
|
r = {}
|
|
c = 0
|
|
for line in data:
|
|
c += 1
|
|
if 'Configurations:' in line:
|
|
break
|
|
for i in range(c, len(data)):
|
|
d = list(filter(None, data[i].strip().split()))
|
|
r[d[0]] = d[1]
|
|
return r
|
|
|
|
def get_device_conf_dict(self, param_name=None):
|
|
""" Get device Configurations
|
|
|
|
:param param_name: if provided retireve only given configuration
|
|
:return: dict {"PARAM_NAME": "Param value", ....}
|
|
"""
|
|
LOG.info("Getting configurations for device: %s" % self.pci_dev)
|
|
cmd = ["mstconfig", "-d", self.pci_dev, "q"]
|
|
if param_name:
|
|
cmd.append(param_name)
|
|
out = run_command(*cmd)
|
|
return self._mstconfig_parse_data(out)
|
|
|
|
def param_supp_by_config_tool(self, param_name):
|
|
""" Check if configuration tool supports the provided configuration
|
|
parameter.
|
|
|
|
:param param_name: configuration name
|
|
:return: bool
|
|
"""
|
|
if self._tool_confs is None:
|
|
self._tool_confs = run_command(
|
|
"mstconfig", "-d", self.pci_dev, "i")
|
|
# trim any array index if present
|
|
indexed_param = re.match(ARRAY_PARAM_REGEX, param_name)
|
|
if indexed_param:
|
|
param_name = indexed_param.group('param_name')
|
|
return param_name in self._tool_confs
|
|
|
|
def _build_config_param_metadata_map(self, conf_dict):
|
|
self.mlnx_config_array_param_metadata = {}
|
|
for param_name, val in six.iteritems(conf_dict):
|
|
array_val = re.match(ARRAY_VALUE_REGEX, val)
|
|
if array_val:
|
|
# Array parameter, extract first/last index
|
|
first_index = array_val.group('first_index')
|
|
last_index = array_val.group('last_index')
|
|
self.mlnx_config_array_param_metadata[param_name] = \
|
|
MlnxConfigArrayParamMetaData(
|
|
param_name, first_index, last_index)
|
|
|
|
def _inflate_array_param_vals_from_query(self, conf_dict):
|
|
""" Inflate provided conf dict with all values of array parameter"""
|
|
inflated_conf = {}
|
|
for param_name, val in six.iteritems(conf_dict):
|
|
if param_name in self.mlnx_config_array_param_metadata:
|
|
param_meta = self.mlnx_config_array_param_metadata[param_name]
|
|
first = param_meta.first_index
|
|
last = param_meta.last_index
|
|
arr_param_val = self.get_device_conf_dict(
|
|
param_name="%s[%s..%s]" % (param_name, first, last))
|
|
# Add new keys to dict
|
|
for k, v in six.iteritems(arr_param_val):
|
|
inflated_conf[k] = v
|
|
else:
|
|
inflated_conf[param_name] = val
|
|
return inflated_conf
|
|
|
|
def _inflate_single_array_input_val(self, param_name, val):
|
|
conf_dict = {}
|
|
param_meta = self.mlnx_config_array_param_metadata[param_name]
|
|
first = param_meta.first_index
|
|
last = param_meta.last_index
|
|
|
|
if '*' in val:
|
|
if len(val) != 1:
|
|
raise RuntimeError(
|
|
"Invalid input for provided array type parameter. %s:%s"
|
|
% (param_name, val))
|
|
|
|
for idx in range(first, last + 1):
|
|
conf_dict["%s[%s]" % (param_name, idx)] = val['*']
|
|
else:
|
|
for idx, idx_val in six.iteritems(val):
|
|
if int(idx) not in range(first, last + 1):
|
|
LOG.warning(
|
|
"Provided array param index(%s) is out of range "
|
|
"[%s..%s] skipping...", idx, first, last)
|
|
continue
|
|
conf_dict["%s[%s]" % (param_name, idx)] = str(idx_val)
|
|
return conf_dict
|
|
|
|
def _inflate_array_param_vals_from_input(self, conf_dict):
|
|
""" Inflate provided conf dict with all values of array parameter"""
|
|
inflated_conf = {}
|
|
for param_name, val in six.iteritems(conf_dict):
|
|
if param_name in self.mlnx_config_array_param_metadata:
|
|
exp_inp = self._inflate_single_array_input_val(param_name, val)
|
|
# Add to conf_dict
|
|
for k, v in six.iteritems(exp_inp):
|
|
inflated_conf[k] = v
|
|
else:
|
|
inflated_conf[param_name] = val
|
|
|
|
return inflated_conf
|
|
|
|
def set_config(self, conf_dict):
|
|
""" Set device configurations
|
|
|
|
:param conf_dict: a dictionary of:
|
|
{"PARAM_NAME": "Param value to set", ...}
|
|
:return: None
|
|
"""
|
|
current_mlx_config = self.get_device_conf_dict()
|
|
self._build_config_param_metadata_map(current_mlx_config)
|
|
current_mlx_config = self._inflate_array_param_vals_from_query(
|
|
current_mlx_config)
|
|
# inflate user input for array parameters
|
|
conf_dict = self._inflate_array_param_vals_from_input(conf_dict)
|
|
|
|
params_to_set = []
|
|
for key, value in conf_dict.items():
|
|
if not self.param_supp_by_config_tool(key):
|
|
LOG.error(
|
|
"Configuraiton: %s is not supported by mstconfig,"
|
|
" please update to the latest mstflint package." % key)
|
|
continue
|
|
|
|
if current_mlx_config.get(key) and value.lower(
|
|
) not in current_mlx_config.get(key).lower():
|
|
# Aggregate all configurations required to be modified
|
|
params_to_set.append("%s=%s" % (key, value))
|
|
|
|
if params_to_set:
|
|
LOG.info("Setting configurations for device: %s" % self.pci_dev)
|
|
run_command("mstconfig", "-d", self.pci_dev, "-y",
|
|
"set", *params_to_set)
|
|
LOG.info("Set device configurations: Setting %s done successfully",
|
|
" ".join(params_to_set))
|
|
else:
|
|
LOG.info("Set device configurations: No operation required")
|
|
|
|
|
|
class MlnxFirmwareBinary(object):
|
|
|
|
def __init__(self, local_bin_path):
|
|
self.bin_path = local_bin_path
|
|
self.image_info = {}
|
|
|
|
def get_info(self):
|
|
""" Get firmware information from binary
|
|
|
|
Caller should wrap this call under try catch to skip non compliant
|
|
firmware binaries.
|
|
|
|
:return: dict of firmware image attributes
|
|
"""
|
|
if self.image_info.get('file_path', '') == self.bin_path:
|
|
return self.image_info
|
|
self.image_info = {'file_path': self.bin_path}
|
|
cmd = ['mstflint', '-i', self.bin_path, 'query']
|
|
out = run_command(*cmd)
|
|
self.image_info.update(parse_mstflint_query_output(out))
|
|
# Note(adrianc): deep copy ?
|
|
return self.image_info
|
|
|
|
|
|
class MlnxFirmwareBinariesFetcher(object):
|
|
""" A class for fetching firmware binaries form a directory
|
|
provided by a URL link
|
|
|
|
Note: URL MUST point to a directory and end with '/'
|
|
e.g http://www.mysite.com/mlnx_bins/
|
|
"""
|
|
dest_dir = tempfile.mkdtemp(suffix="tripleo_mlnx_firmware")
|
|
|
|
class FileHTMLParser(html_parser.HTMLParser):
|
|
""" A crude HTML Parser to extract files from an HTTP response.
|
|
"""
|
|
|
|
def __init__(self, suffix):
|
|
# HTMLParser is Old style class dont use super() method
|
|
html_parser.HTMLParser.__init__(self)
|
|
self.matches = []
|
|
self.suffix = suffix
|
|
|
|
def handle_starttag(self, tag, attrs):
|
|
for name, val in attrs:
|
|
if name == 'href' and val.endswith(self.suffix):
|
|
self.matches.append(val)
|
|
|
|
def __init__(self, url):
|
|
self.url = url
|
|
|
|
def __del__(self):
|
|
self._cleanup_dest_dir()
|
|
|
|
def _cleanup_dest_dir(self):
|
|
if os.path.exists(MlnxFirmwareBinariesFetcher.dest_dir):
|
|
shutil.rmtree(MlnxFirmwareBinariesFetcher.dest_dir)
|
|
|
|
def _get_file_from_url(self, file_name):
|
|
try:
|
|
full_path = self.url + "/" + file_name
|
|
LOG.info("Downloading file: %s to %s", full_path,
|
|
MlnxFirmwareBinariesFetcher.dest_dir)
|
|
url_data = urlRequest.urlopen(full_path)
|
|
except urlError.HTTPError as e:
|
|
LOG.error("Failed to download data: %s", str(e))
|
|
raise e
|
|
dest_file_path = os.path.join(MlnxFirmwareBinariesFetcher.dest_dir,
|
|
file_name)
|
|
with open(dest_file_path, 'wb') as f:
|
|
f.write(url_data.read())
|
|
return dest_file_path
|
|
|
|
def _get_file_create_bin_obj(self, file_name, fw_bins):
|
|
""" This wrapper method will download a firmware binary,
|
|
create MlnxFirmwareBinary object and append to the provided
|
|
fw_bins list.
|
|
|
|
:return: None
|
|
"""
|
|
try:
|
|
dest_file_path = self._get_file_from_url(file_name)
|
|
fw_bin = MlnxFirmwareBinary(dest_file_path)
|
|
# Note(adrianc): Pre query image, to skip incompatible files
|
|
# in case of Error
|
|
fw_bin.get_info()
|
|
fw_bins.append(fw_bin)
|
|
except Exception as e:
|
|
LOG.warning("Failed to download and query %s, skipping file. "
|
|
"%s", file_name, str(e))
|
|
|
|
def get_firmware_binaries(self):
|
|
""" Get Firmware binaries
|
|
|
|
:return: list containing the files downloaded
|
|
"""
|
|
# get list of files
|
|
# download into dest_dir
|
|
# for each file, create MlnxFirmwareBinary
|
|
# return list of the MlnxFirmwareBinary
|
|
if not self.url.endswith('/'):
|
|
LOG.error("Bad URL provided (%s), expected URL to be a directory",
|
|
self.url)
|
|
raise RuntimeError('Failed to get firmware binaries, '
|
|
'expected directory URL path '
|
|
'(e.g "http://<your_ip>/mlnx_bins/"). '
|
|
'Given URL path: %s', self.url)
|
|
try:
|
|
index_data = str(urlRequest.urlopen(_BIN_DIR_URL).read())
|
|
except urlError.HTTPError as err:
|
|
LOG.error(err)
|
|
raise err
|
|
parser = MlnxFirmwareBinariesFetcher.FileHTMLParser(suffix=".bin")
|
|
parser.feed(index_data)
|
|
parser.close()
|
|
if not parser.matches:
|
|
LOG.warning("No bin Files found in the provided URL: %s", self.url)
|
|
|
|
fw_bins = []
|
|
threads = []
|
|
for file_name in parser.matches:
|
|
# TODO(adrianc) fetch files async with co-routines,
|
|
# may need to limit thread count
|
|
t = threading.Thread(target=self._get_file_create_bin_obj,
|
|
args=(file_name, fw_bins))
|
|
t.start()
|
|
threads.append(t)
|
|
for t in threads:
|
|
t.join()
|
|
return fw_bins
|
|
|
|
|
|
class MlnxDevFirmwareOps(object):
|
|
""" Perform various Firmware related operations on device
|
|
"""
|
|
|
|
def __init__(self, dev):
|
|
self.dev = dev
|
|
self.dev_info = {}
|
|
|
|
def query_device(self, force=False):
|
|
""" Get firmware information from device
|
|
|
|
:param force: force device query, even if query was executed in
|
|
previous calls.
|
|
:return: dict of firmware image attributes
|
|
"""
|
|
if not force and self.dev_info.get('device', '') == self.dev:
|
|
return self.dev_info
|
|
|
|
self.dev_info = {'device': self.dev}
|
|
cmd = ['mstflint', '-d', self.dev, '-qq', 'query']
|
|
out = run_command(*cmd)
|
|
self.dev_info = parse_mstflint_query_output(out)
|
|
# Note(adrianc): deep copy ?
|
|
return self.dev_info
|
|
|
|
def need_update(self, image_info):
|
|
""" Check if device requires firmware update
|
|
|
|
:param image_info: image_info dict as returned from
|
|
MlnxFirmwareBinary.get_info()
|
|
:return: bool, True if update is needed
|
|
"""
|
|
if not self.dev_info:
|
|
self.query_device()
|
|
LOG.info("Device firmware version: %s, Image firmware version: %s" %
|
|
(self.dev_info['fw_ver'], image_info['fw_ver']))
|
|
return self.dev_info['fw_ver'] < image_info['fw_ver']
|
|
|
|
def need_reset_before_config(self):
|
|
""" Check if device requires firmware reset before applying any
|
|
configurations on the device.
|
|
|
|
:return: (bool, bool) True if reset is needed,
|
|
True if skip_fms_sync is needed
|
|
"""
|
|
self.query_device(force=True)
|
|
next_boot_image_newer = 'running_fw_ver' in self.dev_info and \
|
|
self.dev_info['running_fw_ver'] < self.dev_info['fw_ver']
|
|
if next_boot_image_newer:
|
|
mandatory_params = ["ESWITCH_IPV4_TTL_MODIFY_ENABLE",
|
|
"PRIO_TAG_REQUIRED_EN",
|
|
"INTERNAL_CPU_PAGE_SUPPLIE",
|
|
"INTERNAL_CPU_ESWITCH_MANAGE",
|
|
"INTERNAL_CPU_IB_VPORT0",
|
|
"INTERNAL_CPU_OFFLOAD_ENGINE"]
|
|
device_config = MlnxDeviceConfig(self.dev)
|
|
conf_dict = device_config.get_device_conf_dict()
|
|
for param in mandatory_params:
|
|
if param not in conf_dict and \
|
|
device_config.param_supp_by_config_tool(param):
|
|
if "INTERNAL_CPU_MODEL" in conf_dict:
|
|
if self.dev_info['running_fw_ver'] < "24.32.0000":
|
|
# In case the device is BlueField and the FW is less than Nov release
|
|
# return True, True to do reset with skip_fms_sync
|
|
return True, True
|
|
elif (self.dev_info['running_fw_ver'] >= "24.32.0000" and
|
|
self.dev_info['running_fw_ver'] < "24.33.0000"):
|
|
# In case the device is BlueField and the FW is from Nov release
|
|
# reset will fail, so don't do it
|
|
return False, False
|
|
return True, False
|
|
return False, False
|
|
|
|
def burn_firmware(self, image_path):
|
|
""" Burn firmware on device
|
|
|
|
:param image_path: firmware binary file path
|
|
:return: None
|
|
"""
|
|
LOG.info("Updating firmware image (%s) for device: %s",
|
|
image_path, self.dev)
|
|
cmd = ["mstflint", "-d", self.dev, "-i", image_path,
|
|
"-y", "burn"]
|
|
run_command(*cmd)
|
|
LOG.info("Device %s: Successfully updated.", self.dev)
|
|
|
|
def reset_device(self, skip_fms_sync=False):
|
|
""" Reset firmware
|
|
|
|
:return: None
|
|
"""
|
|
LOG.info("Device %s: Performing firmware reset.", self.dev)
|
|
if skip_fms_sync:
|
|
cmd = ["mstfwreset", "-d", self.dev, "--skip_fsm_sync", "-y",
|
|
"--sync", _RESET_SYNC, "reset"]
|
|
else:
|
|
cmd = ["mstfwreset", "-d", self.dev, "-y", "reset"]
|
|
run_command(*cmd)
|
|
LOG.info("Device %s: Firmware successfully reset.", self.dev)
|
|
|
|
|
|
def check_prereq():
|
|
""" Check that all needed tools are available in the system.
|
|
|
|
:return: None
|
|
"""
|
|
try:
|
|
# check for mstflint
|
|
run_command('mstflint', '-v')
|
|
# check for mstconfig
|
|
run_command('mstconfig', '-v')
|
|
# check for mstfwreset
|
|
run_command('mstfwreset', '-v')
|
|
# check for lspci
|
|
run_command('lspci', '--version')
|
|
except Exception as e:
|
|
LOG.error("Failed Prerequisite check. %s", str(e))
|
|
raise e
|
|
|
|
|
|
def process_device(pci_dev, psid_map):
|
|
""" Process a single Mellanox device.
|
|
|
|
Processing pipeline:
|
|
- Perform firmware update if required
|
|
- Reset device to load firmware if required
|
|
- Perform device configurations if required
|
|
|
|
:param pci_dev: nvidia nic PCI device address (String)
|
|
:param psid_map: dict mapping between PSID and an image_info dict
|
|
:return: None
|
|
"""
|
|
try:
|
|
LOG.info("Processing Device: %s", pci_dev)
|
|
dev_ops = MlnxDevFirmwareOps(pci_dev)
|
|
device_config = MlnxDeviceConfig(pci_dev)
|
|
dev_query = dev_ops.query_device()
|
|
# see if there is a matching bin
|
|
dev_psid = dev_query['psid']
|
|
if dev_psid in psid_map:
|
|
if _FORCE_UPDATE or dev_ops.need_update(psid_map[dev_psid]):
|
|
dev_ops.burn_firmware(psid_map[dev_psid]['file_path'])
|
|
else:
|
|
LOG.info("Firmware update is not required for Device.")
|
|
else:
|
|
LOG.info("No firmware binary found for device %s with "
|
|
"PSID: %s, skipping...", pci_dev, dev_psid)
|
|
# check if reset is required.
|
|
# Note: device Reset is required if a newer firmware version was burnt
|
|
# and current firmware does not support some mandatory configurations.
|
|
# Note: skip_fms_sync is required if device is BlueField SmartNIC and
|
|
# the current FW is less than Nov release
|
|
need_rest, need_skip_fms_sync = dev_ops.need_reset_before_config()
|
|
if need_rest:
|
|
dev_ops.reset_device(skip_fms_sync=need_skip_fms_sync)
|
|
# set device configurations
|
|
device_config.set_config(_MLX_CONFIG)
|
|
LOG.info("Device %s processed successfully.", pci_dev)
|
|
except Exception as e:
|
|
LOG.error("Failed to process device %s. %s", pci_dev, str(e))
|
|
|
|
|
|
def main():
|
|
check_prereq()
|
|
# discover devices
|
|
mlnx_devices = MlnxDevices(_DEV_WHITE_LIST)
|
|
mlnx_devices.discover()
|
|
# get binaries and prep psid map
|
|
psid_map = {}
|
|
if _BIN_DIR_URL:
|
|
binary_getter = MlnxFirmwareBinariesFetcher(_BIN_DIR_URL)
|
|
fw_binaries = binary_getter.get_firmware_binaries()
|
|
|
|
for fw_bin in fw_binaries:
|
|
image_info = fw_bin.get_info()
|
|
psid_map[image_info['psid']] = image_info
|
|
# process devices
|
|
for pci_dev in mlnx_devices:
|
|
process_device(pci_dev, psid_map)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
|
|
params:
|
|
$BIN_DIR_URL: {get_param: BIN_DIR_URL}
|
|
$FORCE_UPDATE: {get_param: FORCE_UPDATE}
|
|
$DEV_WHITE_LIST: {get_param: DEV_WHITE_LIST}
|
|
$NUM_OF_VFS: {get_param: NUM_OF_VFS}
|
|
$SRIOV_EN: {get_param: SRIOV_EN}
|
|
$LINK_TYPE: {get_param: LINK_TYPE}
|
|
$ESWITCH_IPV4_TTL_MODIFY_ENABLE: {get_param: ESWITCH_IPV4_TTL_MODIFY_ENABLE}
|
|
$PRIO_TAG_REQUIRED_EN: {get_param: PRIO_TAG_REQUIRED_EN}
|
|
$ESWITCH_HAIRPIN_TOT_BUFFER_SIZE: {get_param: ESWITCH_HAIRPIN_TOT_BUFFER_SIZE}
|
|
$ESWITCH_HAIRPIN_DESCRIPTORS: {get_param: ESWITCH_HAIRPIN_DESCRIPTORS}
|
|
$BF_NIC_MODE: {get_param: BF_NIC_MODE}
|
|
$RESET_SYNC: {get_param: RESET_SYNC}
|
|
|
|
|
|
outputs:
|
|
# This means get_resource from the parent template will get the userdata, see:
|
|
# http://docs.openstack.org/developer/heat/template_guide/composition.html#making-your-template-resource-more-transparent
|
|
# Note this is new-for-kilo, an alternative is returning a value then using
|
|
# get_attr in the parent template instead.
|
|
OS::stack_id:
|
|
value: {get_resource: userdata}
|