def install_driver(self):
"""
Install the KVP daemon and the appropriate RDMA driver package for the
RDMA firmware.
"""
# Check and install the KVP deamon if it not running
time.sleep(10) # give some time for the hv_hvp_daemon to start up.
kvpd_running = RDMAHandler.is_kvp_daemon_running()
logger.info('RDMA: kvp daemon running: %s' % kvpd_running)
if not kvpd_running:
self.check_or_install_kvp_daemon()
time.sleep(10) # wait for post-install reboot or kvp to come up
# Find out RDMA firmware version and see if the existing package needs
# updating or if the package is missing altogether (and install it)
fw_version = RDMAHandler.get_rdma_version()
if not fw_version:
raise Exception('Cannot determine RDMA firmware version')
logger.info("RDMA: found firmware version: {0}".format(fw_version))
fw_version = self.get_int_rdma_version(fw_version)
installed_pkg = self.get_rdma_package_info()
if installed_pkg:
logger.info(
'RDMA: driver package present: {0}'.format(installed_pkg))
if self.is_rdma_package_up_to_date(installed_pkg, fw_version):
logger.info('RDMA: driver package is up-to-date')
return
else:
logger.info('RDMA: driver package needs updating')
self.update_rdma_package(fw_version)
else:
logger.info('RDMA: driver package is NOT installed')
self.update_rdma_package(fw_version)
def install_driver(self):
"""
Install the KVP daemon and the appropriate RDMA driver package for the
RDMA firmware.
"""
# Check and install the KVP deamon if it not running
time.sleep(10) # give some time for the hv_hvp_daemon to start up.
kvpd_running = RDMAHandler.is_kvp_daemon_running()
logger.info('RDMA: kvp daemon running: %s' % kvpd_running)
if not kvpd_running:
self.check_or_install_kvp_daemon()
time.sleep(10) # wait for post-install reboot or kvp to come up
# Find out RDMA firmware version and see if the existing package needs
# updating or if the package is missing altogether (and install it)
fw_version = RDMAHandler.get_rdma_version()
if not fw_version:
raise Exception('Cannot determine RDMA firmware version')
logger.info("RDMA: found firmware version: {0}".format(fw_version))
fw_version = self.get_int_rdma_version(fw_version)
installed_pkg = self.get_rdma_package_info()
if installed_pkg:
logger.info(
'RDMA: driver package present: {0}'.format(installed_pkg))
if self.is_rdma_package_up_to_date(installed_pkg, fw_version):
logger.info('RDMA: driver package is up-to-date')
return
else:
logger.info('RDMA: driver package needs updating')
self.update_rdma_package(fw_version)
else:
logger.info('RDMA: driver package is NOT installed')
self.update_rdma_package(fw_version)
def get_rdma_handler(distro_full_name=DISTRO_FULL_NAME,
distro_version=DISTRO_VERSION):
"""Return the handler object for RDMA driver handling"""
if (distro_full_name == 'SUSE Linux Enterprise Server'
and int(distro_version) > 11):
return SUSERDMAHandler()
if distro_full_name == 'CentOS Linux' or distro_full_name == 'CentOS':
return CentOSRDMAHandler(distro_version)
logger.info("No RDMA handler exists for distro='{0}' version='{1}'",
distro_full_name, distro_version)
return RDMAHandler()
def get_rdma_handler(distro_full_name=DISTRO_FULL_NAME,
distro_version=DISTRO_VERSION):
"""Return the handler object for RDMA driver handling"""
if ((distro_full_name == 'SUSE Linux Enterprise Server'
or distro_full_name == 'SLES')
and Version(distro_version) > Version('11')):
return SUSERDMAHandler()
if distro_full_name == 'CentOS Linux' or distro_full_name == 'CentOS' or distro_full_name == 'Red Hat Enterprise Linux Server':
return CentOSRDMAHandler(distro_version)
if distro_full_name == 'Ubuntu':
return UbuntuRDMAHandler()
logger.info("No RDMA handler exists for distro='{0}' version='{1}'",
distro_full_name, distro_version)
return RDMAHandler()
def install_driver(self):
"""
Install the KVP daemon and the appropriate RDMA driver package for the
RDMA firmware.
"""
fw_version = RDMAHandler.get_rdma_version()
if not fw_version:
raise Exception('Cannot determine RDMA firmware version')
logger.info("RDMA: found firmware version: {0}".format(fw_version))
fw_version = self.get_int_rdma_version(fw_version)
installed_pkg = self.get_rdma_package_info()
if installed_pkg:
logger.info(
'RDMA: driver package present: {0}'.format(installed_pkg))
if self.is_rdma_package_up_to_date(installed_pkg, fw_version):
logger.info('RDMA: driver package is up-to-date')
return
else:
logger.info('RDMA: driver package needs updating')
self.update_rdma_package(fw_version)
else:
logger.info('RDMA: driver package is NOT installed')
self.update_rdma_package(fw_version)
def install_driver(self):
#Install the appropriate driver package for the RDMA firmware
nd_version = RDMAHandler.get_rdma_version()
if not nd_version:
logger.error(
"RDMA: Could not determine firmware version. No driver will be installed"
)
return
#replace . with _, we are looking for number like 144_0
nd_version = re.sub('\.', '_', nd_version)
#Check to see if we need to reconfigure driver
status, module_name = shellutil.run_get_output(
'modprobe -R hv_network_direct', chk_err=False)
if status != 0:
logger.info(
"RDMA: modprobe -R hv_network_direct failed. Use module name hv_network_direct"
)
module_name = "hv_network_direct"
else:
module_name = module_name.strip()
logger.info("RDMA: current RDMA driver %s nd_version %s" %
(module_name, nd_version))
if module_name == 'hv_network_direct_%s' % nd_version:
logger.info(
"RDMA: driver is installed and ND version matched. Skip reconfiguring driver"
)
return
#Reconfigure driver if one is available
status, output = shellutil.run_get_output(
'modinfo hv_network_direct_%s' % nd_version)
if status == 0:
logger.info(
"RDMA: driver with ND version is installed. Link to module name"
)
self.update_modprobed_conf(nd_version)
return
#Driver not found. We need to check to see if we need to update kernel
if not conf.enable_rdma_update():
logger.info("RDMA: driver update is disabled. Skip kernel update")
return
status, output = shellutil.run_get_output('uname -r')
if status != 0:
return
if not re.search('-azure$', output):
logger.error("RDMA: skip driver update on non-Azure kernel")
return
kernel_version = re.sub('-azure$', '', output)
kernel_version = re.sub('-', '.', kernel_version)
#Find the new kernel package version
status, output = shellutil.run_get_output('apt-get update')
if status != 0:
return
status, output = shellutil.run_get_output(
'apt-cache show --no-all-versions linux-azure')
if status != 0:
return
r = re.search('Version: (\S+)', output)
if not r:
logger.error("RDMA: version not found in package linux-azure.")
return
package_version = r.groups()[0]
#Remove the ending .<upload number> after <ABI number>
package_version = re.sub("\.\d+$", "", package_version)
logger.info('RDMA: kernel_version=%s package_version=%s' %
(kernel_version, package_version))
kernel_version_array = [int(x) for x in kernel_version.split('.')]
package_version_array = [int(x) for x in package_version.split('.')]
if kernel_version_array < package_version_array:
logger.info(
"RDMA: newer version available, update kernel and reboot")
status, output = shellutil.run_get_output(
'apt-get -y install linux-azure')
if status:
logger.error("RDMA: kernel update failed")
return
self.reboot_system()
else:
logger.error(
"RDMA: no kernel update is avaiable for ND version %s" %
nd_version)
def install_driver(self):
"""Install the appropriate driver package for the RDMA firmware"""
fw_version = RDMAHandler.get_rdma_version()
if not fw_version:
error_msg = 'RDMA: Could not determine firmware version. '
error_msg += 'Therefore, no driver will be installed.'
logger.error(error_msg)
return
zypper_install = 'zypper -n in %s'
zypper_install_noref = 'zypper -n --no-refresh in %s'
zypper_remove = 'zypper -n rm %s'
zypper_search = 'zypper -n se -s %s'
package_name = 'msft-rdma-kmp-default'
cmd = zypper_search % package_name
status, repo_package_info = shellutil.run_get_output(cmd)
driver_package_versions = []
driver_package_installed = False
for entry in repo_package_info.split('\n'):
if package_name in entry:
sections = entry.split('|')
if len(sections) < 4:
error_msg = 'RDMA: Unexpected output from"%s": "%s"'
logger.error(error_msg % (cmd, entry))
continue
installed = sections[0].strip()
version = sections[3].strip()
driver_package_versions.append(version)
if fw_version in version and installed == 'i':
info_msg = 'RDMA: Matching driver package "%s-%s" '
info_msg += 'is already installed, nothing to do.'
logger.info(info_msg % (package_name, version))
return True
if installed == 'i':
driver_package_installed = True
# If we get here the driver package is installed but the
# version doesn't match or no package is installed
requires_reboot = False
if driver_package_installed:
# Unloading the particular driver with rmmod does not work
# We have to reboot after the new driver is installed
if self.is_driver_loaded():
info_msg = 'RDMA: Currently loaded driver does not match the '
info_msg += 'firmware implementation, reboot will be required.'
logger.info(info_msg)
requires_reboot = True
logger.info("RDMA: removing package %s" % package_name)
cmd = zypper_remove % package_name
shellutil.run(cmd)
logger.info("RDMA: removed package %s" % package_name)
logger.info("RDMA: looking for fw version %s in packages" % fw_version)
for entry in driver_package_versions:
if not fw_version in version:
logger.info("Package '%s' is not a match." % entry)
else:
logger.info("Package '%s' is a match. Installing." % entry)
complete_name = '%s-%s' % (package_name, version)
cmd = zypper_install % complete_name
result = shellutil.run(cmd)
if result:
error_msg = 'RDMA: Failed install of package "%s" '
error_msg += 'from available repositories.'
logger.error(error_msg % complete_name)
msg = 'RDMA: Successfully installed "%s" from '
msg += 'configured repositories'
logger.info(msg % complete_name)
if not self.load_driver_module() or requires_reboot:
self.reboot_system()
return True
else:
logger.info("RDMA: No suitable match in repos. Trying local.")
local_packages = glob.glob('/opt/microsoft/rdma/*.rpm')
for local_package in local_packages:
logger.info("Examining: %s" % local_package)
if local_package.endswith('.src.rpm'):
continue
if (package_name in local_package
and fw_version in local_package):
logger.info("RDMA: Installing: %s" % local_package)
cmd = zypper_install_noref % local_package
result = shellutil.run(cmd)
if result and result != 106:
error_msg = 'RDMA: Failed install of package "%s" '
error_msg += 'from local package cache'
logger.error(error_msg % local_package)
break
msg = 'RDMA: Successfully installed "%s" from '
msg += 'local package cache'
logger.info(msg % (local_package))
if not self.load_driver_module() or requires_reboot:
self.reboot_system()
return True
else:
error_msg = 'Unable to find driver package that matches '
error_msg += 'RDMA firmware version "%s"' % fw_version
logger.error(error_msg)
return
def install_driver(self):
"""Install the appropriate driver package for the RDMA firmware"""
fw_version = RDMAHandler.get_rdma_version()
if not fw_version:
error_msg = 'RDMA: Could not determine firmware version. '
error_msg += 'Therefore, no driver will be installed.'
logger.error(error_msg)
return
zypper_install = 'zypper -n in %s'
zypper_remove = 'zypper -n rm %s'
zypper_search = 'zypper se -s %s'
package_name = 'msft-rdma-kmp-default'
cmd = zypper_search % package_name
status, repo_package_info = shellutil.run_get_output(cmd)
driver_package_versions = []
driver_package_installed = False
for entry in repo_package_info.split('\n'):
if package_name in entry:
sections = entry.split('|')
if len(sections) < 4:
error_msg = 'RDMA: Unexpected output from"%s": "%s"'
logger.error(error_msg % (cmd, entry))
continue
installed = sections[0].strip()
version = sections[3].strip()
driver_package_versions.append(version)
if fw_version in version and installed == 'i':
info_msg = 'RDMA: Matching driver package "%s-%s" '
info_msg += 'is already installed, nothing to do.'
logger.info(info_msg % (package_name, version))
return True
if installed == 'i':
driver_package_installed = True
# If we get here the driver package is installed but the
# version doesn't match or no package is installed
requires_reboot = False
if driver_package_installed:
# Unloading the particular driver with rmmod does not work
# We have to reboot after the new driver is installed
if self.is_driver_loaded():
info_msg = 'RDMA: Currently loaded driver does not match the '
info_msg += 'firmware implementation, reboot will be required.'
logger.info(info_msg)
requires_reboot = True
logger.info("RDMA: removing package %s" % package_name)
cmd = zypper_remove % package_name
shellutil.run(cmd)
logger.info("RDMA: removed package %s" % package_name)
logger.info("RDMA: looking for fw version %s in packages" % fw_version)
for entry in driver_package_versions:
if not fw_version in version:
logger.info("Package '%s' is not a match." % entry)
else:
logger.info("Package '%s' is a match. Installing." % entry)
complete_name = '%s-%s' % (package_name, version)
cmd = zypper_install % complete_name
result = shellutil.run(cmd)
if result:
error_msg = 'RDMA: Failed install of package "%s" '
error_msg += 'from available repositories.'
logger.error(error_msg % complete_name)
msg = 'RDMA: Successfully installed "%s" from '
msg += 'configured repositories'
logger.info(msg % complete_name)
self.load_driver_module()
if requires_reboot:
self.reboot_system()
return True
else:
logger.info("RDMA: No suitable match in repos. Trying local.")
local_packages = glob.glob('/opt/microsoft/rdma/*.rpm')
for local_package in local_packages:
logger.info("Examining: %s" % local_package)
if local_package.endswith('.src.rpm'):
continue
if (
package_name in local_package and
fw_version in local_package
):
logger.info("RDMA: Installing: %s" % local_package)
cmd = zypper_install % local_package
result = shellutil.run(cmd)
if result:
error_msg = 'RDMA: Failed install of package "%s" '
error_msg += 'from local package cache'
logger.error(error_msg % local_package)
break
msg = 'RDMA: Successfully installed "%s" from '
msg += 'local package cache'
logger.info(msg % (local_package))
self.load_driver_module()
if requires_reboot:
self.reboot_system()
return True
else:
error_msg = 'Unable to find driver package that matches '
error_msg += 'RDMA firmware version "%s"' % fw_version
logger.error(error_msg)
return
