def setUp(self):
"""
Setup checks :
0. Processor should be ppc64.
1. Install perf package
2. Check for hv_24x7/hv_gpci cpumask
3. Offline the cpumask CPU and check cpumask moved to new CPU or not
"""
smm = SoftwareManager()
processor_type = genio.read_file("/proc/cpuinfo")
detected_distro = distro.detect()
# Offline cpu list during the test
self.cpu_off = []
if 'ppc64' not in detected_distro.arch:
self.cancel("Processor is not PowerPC")
for line in processor_type.splitlines():
if 'revision' in line:
self.rev = (line.split(':')[1])
if '0080' not in self.rev:
self.cancel("Test is supported only on Power10")
deps = ['gcc', 'make']
if 'Ubuntu' in detected_distro.name:
deps.extend(
['linux-tools-common',
'linux-tools-%s' % platform.uname()[2]])
elif detected_distro.name in ['rhel', 'SuSE', 'fedora', 'centos']:
deps.extend(['perf'])
else:
self.cancel("Install the package for perf supported by %s" %
detected_distro.name)
for package in deps:
if not smm.check_installed(package) and not smm.install(package):
self.cancel('%s is needed for the test to be run' % package)
hv24x7_present = False
hvgpci_present = False
self.hv24x7_cpumask = False
self.hvpgci_cpumask = False
hv24x7_present, self.hv24x7_cpumask = self._check_file("hv_24x7")
hvgpci_present, self.hvpgci_cpumask = self._check_file("hv_gpci")
# To proceed with the test we need either of hv_24x7 or hv_gpci
if not (hv24x7_present and hvgpci_present):
self.fail("hv_24x7 and hv_gpci both events not found")
# Collect the cpu list
self.online_cpus = cpu.online_list()
self.log.info("Online CPU list: %s" % self.online_cpus)
# Clear the dmesg to capture the delta at the end of the test.
dmesg.clear_dmesg()
def tearDown(self):
"""
Cleanup of disk used to perform this test
"""
if self.disk is not None:
if self.fs_create:
self.delete_fs(self.target)
if self.lv_create:
self.delete_lv()
if self.raid_create:
self.delete_raid()
dmesg.clear_dmesg()
if self.err_mesg:
self.warn("test failed due to following errors %s" % self.err_mesg)
def execute_test(self):
self.log.info("============== Enabling livepatching ===============")
dmesg.clear_dmesg()
self.is_fail = 0
self.run_cmd("insmod ./livepatch-sample.ko")
if self.is_fail >= 1:
self.fail("insmod livepatch-sample.ko failed")
if "enabling patch" not in \
self.run_cmd_out("dmesg |grep -i livepatch_sample"):
self.fail("livepatch couldn't be enabled, "
"check dmesg for more information")
"""
Execute /proc/cmdline, to check if livepatch works
"""
if "this has been live patched" not \
in genio.read_one_line("/proc/cmdline"):
self.fail("livepatching unsuccessful, "
"check dmesg for more information")
self.log.info("=========== Disabling livepatching ===============")
genio.write_one_line(
"/sys/kernel/livepatch/livepatch_sample/enabled", "0")
if "0" not in genio.read_one_line("/sys/kernel/livepatch/"
"livepatch_sample/enabled"):
self.fail("Unable to disable livepatch "
"for livepatch_sample module")
if "unpatching transition" not in \
self.run_cmd_out("dmesg |grep -i livepatch_sample"):
self.fail(
"livepatch couldn't be disabled, check dmesg "
"for more information")
if "this has been live patched" in \
genio.read_one_line("/proc/cmdline"):
self.fail(
"livepatching disabling unsuccessful, check dmesg "
"for more information")
"""
Wait for 3 minutes before trying to remove the livepatching module
"""
time.sleep(60 * 3)
self.run_cmd("rmmod livepatch-sample")
if self.is_fail >= 1:
self.log.info("rmmod livepatch-sample.ko failed, "
"try removing it manual after sometime")
def tearDown(self):
'''
Cleanup of disk used to perform this test
'''
if os.path.exists(self.fio_file):
os.remove(self.fio_file)
if self.fs_create:
self.delete_fs(self.target)
if self.lv_create:
self.delete_lv()
if self.raid_create:
self.delete_raid()
dmesg.clear_dmesg()
if self.err_mesg:
self.warn("test failed due to following errors %s" % self.err_mesg)
def test_fsstress_run(self):
'''
Downloads LTP, compiles, installs and runs filesystem
tests on a user specified disk
'''
arg = (" -d %s -n %s -p %s -r -l %s"
% (self.dir, self.n_val, self.p_val, self.fsstress_count))
self.log.info("Args = %s" % arg)
dmesg.clear_dmesg()
cmd = './fsstress %s' % arg
process.run(cmd, ignore_status=True)
cmd = "dmesg --level=err"
if process.system_output(cmd, shell=True,
ignore_status=True, sudo=False):
self.fail("FSSTRESS test failed")
def basic_eeh(self, func, pci_class_name, pci_interface,
pci_mem_addr, pci_mask, add_cmd):
"""
Injects Error, and checks for PE recovery
returns True, if recovery is success, else Flase
"""
dmesg.clear_dmesg()
if self.is_baremetal():
return_code = self.error_inject(func, '', '', self.mem_addr,
self.mask, '', self.addr,
self.err, self.phb)
else:
return_code = self.error_inject(func, pci_class_name,
pci_interface, pci_mem_addr,
pci_mask, add_cmd, '', '', '')
if return_code != EEH_HIT:
self.log.info("Skipping verification, as command failed")
if not self.check_eeh_hit():
self.log.info("PE %s EEH hit failed" % self.pci_device)
return EEH_MISS
else:
self.log.info("PE %s EEH hit success" % self.pci_device)
return EEH_HIT
def setUp(self):
"""
Setup checks :
0. Processor should be ppc64.
1. Install perf package
2. Check for metric/metric group
3. When found metric/metric group run all the events
"""
smm = SoftwareManager()
detected_distro = distro.detect()
if 'ppc64' not in detected_distro.arch:
self.cancel("Processor is not PowerPC")
deps = ['gcc', 'make']
if 'Ubuntu' in detected_distro.name:
deps.extend(
['linux-tools-common',
'linux-tools-%s' % platform.uname()[2]])
elif detected_distro.name in ['rhel', 'SuSE', 'fedora', 'centos']:
deps.extend(['perf', 'numactl'])
else:
self.cancel("Install the package for perf supported by %s" %
detected_distro.name)
for package in deps:
if not smm.check_installed(package) and not smm.install(package):
self.cancel('%s is needed for the test to be run' % package)
# Collect all metric events and metric group events
self.list_of_metric_events = []
self._create_all_metric_events('metric')
self._create_all_metric_events('metricgroup')
if not self.list_of_metric_events:
self.cancel("perf tool Metric events not found.")
# Clear the dmesg to capture the delta at the end of the test.
dmesg.clear_dmesg()
def setUp(self):
'''
set up required packages and gather necessary test inputs
'''
self.install_packages()
self.hmc_ip = self.get_mcp_component("HMCIPAddr")
if not self.hmc_ip:
self.cancel("HMC IP not got")
self.hmc_pwd = self.params.get("hmc_pwd", '*', default=None)
self.hmc_username = self.params.get("hmc_username", '*', default=None)
self.lpar = self.get_partition_name("Partition Name")
if not self.lpar:
self.cancel("LPAR Name not got from lparstat command")
for root, dirct, files in os.walk("/root/.ssh"):
for file in files:
if file.startswith("avocado-master-root"):
path = os.path.join(root, file)
os.remove(path)
self.session_hmc = Session(self.hmc_ip,
user=self.hmc_username,
password=self.hmc_pwd)
if not self.session_hmc.connect():
self.cancel("failed connecting to HMC")
cmd = 'lssyscfg -r sys -F name'
output = self.session_hmc.cmd(cmd)
self.server = ''
for line in output.stdout_text.splitlines():
if line in self.lpar:
self.server = line
break
if not self.server:
self.cancel("Managed System not got")
self.slot_num = self.params.get("slot_num", '*', default=None)
self.slot_num = self.slot_num.split(' ')
for slot in self.slot_num:
if int(slot) < 3 or int(slot) > 2999:
self.cancel("Slot invalid. Valid range: 3 - 2999")
self.vios_name = self.params.get("vios_names", '*',
default=None).split(' ')
self.sriov_port = self.params.get("sriov_ports", '*',
default=None).split(' ')
self.backing_adapter = self.params.get("sriov_adapters",
'*',
default=None).split(' ')
if len(self.sriov_port) != len(self.backing_adapter):
self.cancel('Backing Device counts and port counts differ')
if len(self.vios_name) != len(self.backing_adapter):
self.cancel('Backing Device counts and vios name counts differ')
self.backingdev_count = len(self.backing_adapter)
self.bandwidth = self.params.get("bandwidth", '*', default=None)
self.vnic_priority = self.params.get("priority", '*', default=None)
if not self.vnic_priority:
self.vnic_priority = [50] * len(self.backing_adapter)
else:
self.vnic_priority = self.vnic_priority.split(' ')
if len(self.vnic_priority) != len(self.backing_adapter):
self.cancel('Backing Device counts and priority counts differ')
self.auto_failover = self.params.get("auto_failover",
'*',
default=None)
if self.auto_failover not in ['0', '1']:
self.auto_failover = '1'
self.vios_ip = self.params.get('vios_ip', '*', default=None)
self.vios_user = self.params.get('vios_username', '*', default=None)
self.vios_pwd = self.params.get('vios_pwd', '*', default=None)
self.count = int(self.params.get('vnic_test_count', default="1"))
self.num_of_dlpar = int(self.params.get("num_of_dlpar", default='1'))
self.device_ip = self.params.get('device_ip', '*',
default=None).split(' ')
self.mac_id = self.params.get('mac_id',
default="02:03:03:03:03:01").split(' ')
self.mac_id = [mac.replace(':', '') for mac in self.mac_id]
self.netmask = self.params.get('netmasks', '*',
default=None).split(' ')
self.peer_ip = self.params.get('peer_ip', default=None).split(' ')
dmesg.clear_dmesg()
self.session_hmc.cmd("uname -a")
cmd = 'lssyscfg -m ' + self.server + \
' -r lpar --filter lpar_names=' + self.lpar + \
' -F lpar_id'
self.lpar_id = self.session_hmc.cmd(cmd).stdout_text.split()[0]
self.vios_id = []
for vios_name in self.vios_name:
cmd = 'lssyscfg -m ' + self.server + \
' -r lpar --filter lpar_names=' + vios_name + \
' -F lpar_id'
self.vios_id.append(
self.session_hmc.cmd(cmd).stdout_text.split()[0])
cmd = 'lshwres -m %s -r sriov --rsubtype adapter -F \
phys_loc:adapter_id' % self.server
adapter_id_output = self.session_hmc.cmd(cmd).stdout_text
self.backing_adapter_id = []
for backing_adapter in self.backing_adapter:
for line in adapter_id_output.splitlines():
if str(backing_adapter) in line:
self.backing_adapter_id.append(line.split(':')[1])
if not self.backing_adapter_id:
self.cancel("SRIOV adapter provided was not found.")
self.rsct_service_start()
if len(self.slot_num) > 1:
if 'backing' in str(self.name.name) or \
'failover' in str(self.name.name):
self.cancel("this test is not needed")
self.local = LocalHost()
cmd = "echo 'module ibmvnic +p; func send_subcrq -p' > /sys/kernel/debug/dynamic_debug/control"
result = process.run(cmd, shell=True, ignore_status=True)
if result.exit_status:
self.fail("failed to enable debug mode")
def setUp(self):
'''
set up required packages and gather necessary test inputs
'''
self.install_packages()
self.rsct_service_start()
self.hmc_ip = self.get_mcp_component("HMCIPAddr")
if not self.hmc_ip:
self.cancel("HMC IP not got from lsrsrc command")
self.hmc_user = self.params.get("hmc_username", default='hscroot')
self.hmc_pwd = self.params.get("hmc_pwd", '*', default='********')
self.options = self.params.get("options", default='')
self.net_device_type = self.params.get("net_device_type", default='')
self.lpar = self.get_partition_name("Partition Name")
if not self.lpar:
self.cancel("LPAR Name not got from lparstat command")
self.lpar_ip = self.get_mcp_component("MNName")
if not self.lpar_ip:
self.cancel("LPAR IP not got from lsrsrc command")
self.session = Session(self.hmc_ip,
user=self.hmc_user,
password=self.hmc_pwd)
if not self.session.connect():
self.cancel("failed connecting to HMC")
cmd = 'lssyscfg -r sys -F name'
output = self.session.cmd(cmd)
self.server = ''
for line in output.stdout_text.splitlines():
if line in self.lpar:
self.server = line
break
if not self.server:
self.cancel("Managed System not got")
self.remote_server = self.params.get("remote_server", default=None)
if not self.remote_server:
self.cancel("No Remote Server specified for LPM")
if 'back' in str(self.name.name):
current_server = self.remote_server
else:
current_server = self.server
if not self.is_lpar_in_server(current_server, self.lpar):
self.cancel("%s not in %s" % (self.lpar, current_server))
if 'vnic' in self.net_device_type:
self.slot_num = str(self.params.get("slot_num", '*', default=3))
if int(self.slot_num) < 3 or int(self.slot_num) > 2999:
self.cancel("Slot invalid. Valid range: 3 - 2999")
self.bandwidth = str(self.params.get("bandwidth", default=2))
self.vios_name = self.params.get("vios_names", '*',
default=None).split(' ')
self.vios_id = []
for vios_name in self.vios_name:
self.vios_id.append(self.get_lpar_id(self.server, vios_name))
self.remote_vios_name = self.params.get("remote_vios_names",
'*',
default=None).split(' ')
self.remote_vios_id = []
for vios_name in self.remote_vios_name:
self.remote_vios_id.append(
self.get_lpar_id(self.remote_server, vios_name))
for vios in self.vios_id:
self.set_msp(self.server, vios)
for vios in self.remote_vios_id:
self.set_msp(self.remote_server, vios)
self.adapters = self.params.get("sriov_adapters",
default='').split(' ')
self.remote_adapters = self.params.get("remote_sriov_adapters",
default='').split(' ')
self.ports = self.params.get("sriov_ports", default='').split(' ')
self.remote_ports = self.params.get("remote_sriov_ports",
default='').split(' ')
self.adapter_id = []
for adapter in self.adapters:
self.adapter_id.append(
self.get_adapter_id(self.server, adapter))
self.remote_adapter_id = []
for adapter in self.remote_adapters:
self.remote_adapter_id.append(
self.get_adapter_id(self.remote_server, adapter))
dmesg.clear_dmesg()
def setUp(self):
"""
Build tiobench.
Source:
https://github.com/mkuoppal/tiobench.git
"""
self.fstype = self.params.get('fs', default='')
self.fs_create = False
lv_needed = self.params.get('lv', default=False)
self.lv_create = False
raid_needed = self.params.get('raid', default=False)
self.raid_create = False
self.disk = self.params.get('disk', default=None)
self.dir = self.params.get('dir', default="/mnt")
self.raid_name = '/dev/md/sraid'
self.vgname = 'avocado_vg'
self.lvname = 'avocado_lv'
self.err_mesg = []
smm = SoftwareManager()
packages = ['gcc', 'mdadm']
if self.fstype == 'btrfs':
ver = int(distro.detect().version)
rel = int(distro.detect().release)
if distro.detect().name == 'rhel':
if (ver == 7 and rel >= 4) or ver > 7:
self.cancel("btrfs is not supported with RHEL 7.4 onwards")
if distro.detect().name == 'Ubuntu':
packages.extend(['btrfs-tools'])
for package in packages:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("%s package required for this test." % package)
locations = ["https://github.com/mkuoppal/tiobench/archive/master.zip"]
tarball = self.fetch_asset("tiobench.zip", locations=locations)
archive.extract(tarball, self.teststmpdir)
os.chdir(os.path.join(self.teststmpdir, "tiobench-master"))
build.make(".")
self.target = self.disk
self.lv_disk = self.disk
self.part_obj = Partition(self.disk, mountpoint=self.dir)
self.sw_raid = softwareraid.SoftwareRaid(self.raid_name, '0',
self.disk.split(), '1.2')
dmesg.clear_dmesg()
if self.disk is not None:
if self.disk:
self.pre_cleanup()
if raid_needed:
self.create_raid(self.disk, self.raid_name)
self.raid_create = True
self.target = self.raid_name
if lv_needed:
self.lv_disk = self.target
self.target = self.create_lv(self.target)
self.lv_create = True
if self.fstype:
self.create_fs(self.target, self.dir, self.fstype)
self.fs_create = True
else:
self.cancel("Missing disk %s in OS" % self.disk)
else:
self.cancel("Please provide a valid disk name")
def setUp(self):
'''
To check and install dependencies for the test
'''
self.fs_create = False
lv_needed = self.params.get('lv', default=False)
self.lv_create = False
raid_needed = self.params.get('raid', default=False)
self.raid_create = False
self.disk = self.params.get('disk', default=None)
self.dir = self.params.get('dir', default='/mnt')
self.fstype = self.params.get('fs', default='ext4')
self.args = self.params.get('args', default='')
smm = SoftwareManager()
packages = ['gcc', 'make', 'automake', 'autoconf']
if raid_needed:
packages.append('mdadm')
for package in packages:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("%s is needed for the test to be run" % package)
if self.fstype == 'btrfs':
ver = int(distro.detect().version)
rel = int(distro.detect().release)
if distro.detect().name == 'rhel':
if (ver == 7 and rel >= 4) or ver > 7:
self.cancel("btrfs is not supported with \
RHEL 7.4 onwards")
self.raid_name = '/dev/md/sraid'
self.vgname = 'avocado_vg'
self.lvname = 'avocado_lv'
self.err_mesg = []
self.target = self.disk
self.lv_disk = self.disk
self.part_obj = Partition(self.disk, mountpoint=self.dir)
self.sw_raid = softwareraid.SoftwareRaid(self.raid_name, '0',
self.disk.split(), '1.2')
dmesg.clear_dmesg()
if self.disk is not None:
self.pre_cleanup()
if self.disk in disk.get_disks():
if raid_needed:
self.create_raid(self.disk, self.raid_name)
self.raid_create = True
self.target = self.raid_name
if lv_needed:
self.lv_disk = self.target
self.target = self.create_lv(self.target)
self.lv_create = True
if self.fstype:
self.create_fs(self.target, self.dir, self.fstype)
self.fs_create = True
else:
self.cancel("Missing disk %s in OS" % self.disk)
else:
self.cancel("please provide valid disk")
url = "https://github.com/linux-test-project/ltp/"
url += "archive/master.zip"
tarball = self.fetch_asset("ltp-master.zip",
locations=[url],
expire='7d')
archive.extract(tarball, self.teststmpdir)
ltp_dir = os.path.join(self.teststmpdir, "ltp-master")
os.chdir(ltp_dir)
build.make(ltp_dir, extra_args='autotools')
self.ltpbin_dir = os.path.join(ltp_dir, 'bin')
if not os.path.isdir(self.ltpbin_dir):
os.mkdir(self.ltpbin_dir)
process.system('./configure --prefix=%s' % self.ltpbin_dir,
ignore_status=True)
build.make(ltp_dir)
build.make(ltp_dir, extra_args='install')
def setUp(self):
"""
Build 'ndctl' and setup the binary.
"""
deps = []
self.dist = distro.detect()
self.package = self.params.get('package', default='upstream')
self.preserve_setup = self.params.get('preserve_change', default=False)
self.mode_to_use = self.params.get('modes', default='fsdax')
if self.dist.name not in ['SuSE', 'rhel']:
self.cancel('Unsupported OS %s' % self.dist.name)
# DAX wont work with reflink, disabling here
self.reflink = '-m reflink=0'
self.smm = SoftwareManager()
if self.package == 'upstream':
deps.extend(['gcc', 'make', 'automake', 'autoconf'])
if self.dist.name == 'SuSE':
deps.extend(['libtool',
'libkmod-devel', 'libudev-devel', 'systemd-devel',
'libuuid-devel-static', 'libjson-c-devel',
'keyutils-devel', 'kmod-bash-completion',
'bash-completion-devel'])
elif self.dist.name == 'rhel':
deps.extend(['libtool', 'bash-completion', 'parted',
'kmod-devel', 'libuuid-devel', 'json-c-devel',
'systemd-devel', 'keyutils-libs-devel', 'jq'])
for pkg in deps:
if not self.smm.check_installed(pkg) and not \
self.smm.install(pkg):
self.cancel('%s is needed for the test to be run' % pkg)
git_branch = self.params.get('git_branch', default='pending')
location = "https://github.com/pmem/ndctl/archive/"
location = location + git_branch + ".zip"
tarball = self.fetch_asset("ndctl.zip", locations=location,
expire='7d')
archive.extract(tarball, self.teststmpdir)
os.chdir("%s/ndctl-%s" % (self.teststmpdir, git_branch))
process.run('./autogen.sh', sudo=True, shell=True)
process.run("./configure CFLAGS='-g -O2' --prefix=/usr "
"--disable-docs "
"--sysconfdir=/etc --libdir="
"/usr/lib64", shell=True, sudo=True)
build.make(".")
self.ndctl = os.path.abspath('./ndctl/ndctl')
self.daxctl = os.path.abspath('./daxctl/daxctl')
else:
deps.extend(['ndctl'])
if self.dist.name == 'rhel':
deps.extend(['daxctl'])
for pkg in deps:
if not self.smm.check_installed(pkg) and not \
self.smm.install(pkg):
self.cancel('%s is needed for the test to be run' % pkg)
self.ndctl = 'ndctl'
self.daxctl = 'daxctl'
self.opt_dict = {'-B': 'provider',
'-D': 'dev', '-R': 'dev', '-N': 'dev'}
self.modes = ['raw', 'sector', 'fsdax', 'devdax']
self.part = None
self.disk = None
self.plib = pmem.PMem(self.ndctl, self.daxctl)
if not self.plib.check_buses():
self.cancel("Test needs atleast one region")
dmesg.clear_dmesg()
def setUp(self):
"""
Use distro provided bonnie++ bin
if not available Build bonnie++ from below
Source:
http://www.coker.com.au/bonnie++/experimental/bonnie++-1.03e.tgz
"""
self.fstype = self.params.get('fs', default='')
self.fs_create = False
lv_needed = self.params.get('lv', default=False)
self.lv_create = False
raid_needed = self.params.get('raid', default=False)
self.raid_create = False
self.disk = self.params.get('disk', default=None)
self.dir = self.params.get('dir', default='/mnt')
self.uid_to_use = self.params.get('uid-to-use',
default=getpass.getuser())
self.number_to_stat = self.params.get('number-to-stat', default=2048)
self.data_size = self.params.get('data_size_to_pass', default=0)
smm = SoftwareManager()
# Install the package from web
deps = ['gcc', 'make']
if distro.detect().name == 'Ubuntu':
deps.extend(['g++'])
else:
deps.extend(['gcc-c++'])
if self.fstype == 'btrfs':
ver = int(distro.detect().version)
rel = int(distro.detect().release)
if distro.detect().name == 'rhel':
if (ver == 7 and rel >= 4) or ver > 7:
self.cancel("btrfs not supported with RHEL 7.4 onwards")
elif distro.detect().name == 'Ubuntu':
deps.extend(['btrfs-tools'])
if raid_needed:
deps.append('mdadm')
for package in deps:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("%s package required for this test" % package)
if process.system("which bonnie++", ignore_status=True):
tarball = self.fetch_asset('http://www.coker.com.au/bonnie++/'
'bonnie++-1.03e.tgz', expire='7d')
archive.extract(tarball, self.teststmpdir)
self.source = os.path.join(self.teststmpdir,
os.path.basename(
tarball.split('.tgz')[0]))
os.chdir(self.source)
process.run('./configure')
build.make(self.source)
build.make(self.source, extra_args='install')
if not os.path.exists(self.dir):
os.mkdir(self.dir)
self.raid_name = '/dev/md/sraid'
self.vgname = 'avocado_vg'
self.lvname = 'avocado_lv'
self.err_mesg = []
self.target = self.disk
self.lv_disk = self.disk
self.part_obj = Partition(self.disk, mountpoint=self.dir)
self.sw_raid = softwareraid.SoftwareRaid(self.raid_name, '0',
self.disk.split(), '1.2')
dmesg.clear_dmesg()
if self.disk is not None:
self.pre_cleanup()
if self.disk in disk.get_disks():
if raid_needed:
self.create_raid(self.disk, self.raid_name)
self.raid_create = True
self.target = self.raid_name
if lv_needed:
self.lv_disk = self.target
self.target = self.create_lv(self.target)
self.lv_create = True
if self.fstype:
self.create_fs(self.target, self.dir, self.fstype)
self.fs_create = True
else:
self.cancel("Missing disk %s in OS" % self.disk)
else:
self.cancel("please provide valid disk")
def setUp(self):
"""
Build 'fio'.
"""
default_url = "https://brick.kernel.dk/snaps/fio-git-latest.tar.gz"
url = self.params.get('fio_tool_url', default=default_url)
self.disk = self.params.get('disk', default=None)
self.dir = self.params.get('dir', default='/mnt')
self.disk_type = self.params.get('disk_type', default='')
fstype = self.params.get('fs', default='')
fs_args = self.params.get('fs_args', default='')
mnt_args = self.params.get('mnt_args', default='')
lv_needed = self.params.get('lv', default=False)
raid_needed = self.params.get('raid', default=False)
self.fio_file = 'fiotest-image'
self.fs_create = False
self.lv_create = False
self.raid_create = False
self.devdax_file = None
if fstype == 'btrfs':
ver = int(distro.detect().version)
rel = int(distro.detect().release)
if distro.detect().name == 'rhel':
if (ver == 7 and rel >= 4) or ver > 7:
self.cancel("btrfs is not supported with \
RHEL 7.4 onwards")
if distro.detect().name in ['Ubuntu', 'debian']:
pkg_list = ['libaio-dev']
if fstype == 'btrfs':
pkg_list.append('btrfs-progs')
elif distro.detect().name is 'SuSE':
pkg_list = ['libaio1', 'libaio-devel']
else:
pkg_list = ['libaio', 'libaio-devel']
if self.disk_type == 'nvdimm':
pkg_list.extend(['autoconf', 'pkg-config'])
if distro.detect().name == 'SuSE':
pkg_list.extend(
['ndctl', 'libnuma-devel', 'libndctl-devel'])
else:
pkg_list.extend([
'ndctl', 'daxctl', 'numactl-devel', 'ndctl-devel',
'daxctl-devel'
])
if raid_needed:
pkg_list.append('mdadm')
smm = SoftwareManager()
for pkg in pkg_list:
if pkg and not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel(
"Package %s is missing and could not be installed" % pkg)
tarball = self.fetch_asset(url)
archive.extract(tarball, self.teststmpdir)
self.sourcedir = os.path.join(self.teststmpdir, "fio")
fio_flags = ""
self.ld_path = ""
self.raid_name = '/dev/md/sraid'
self.vgname = 'avocado_vg'
self.lvname = 'avocado_lv'
self.err_mesg = []
if self.disk_type == 'nvdimm':
self.setup_pmem_disk(mnt_args)
self.log.info("Building PMDK for NVDIMM fio engines")
pmdk_url = self.params.get('pmdk_url', default='')
tar = self.fetch_asset(pmdk_url, expire='7d')
archive.extract(tar, self.teststmpdir)
version = os.path.basename(tar.split('.tar.')[0])
pmdk_src = os.path.join(self.teststmpdir, version)
build.make(pmdk_src)
build.make(pmdk_src,
extra_args='install prefix=%s' % self.teststmpdir)
os.chdir(self.sourcedir)
ext_flags = '`PKG_CONFIG_PATH=%s/lib/pkgconfig pkg-config --cflags\
--libs libpmem libpmemblk`' % self.teststmpdir
self.ld_path = "LD_LIBRARY_PATH=%s/lib" % self.teststmpdir
out = process.system_output('./configure --extra-cflags='
'"%s"' % ext_flags,
shell=True)
fio_flags = "LDFLAGS='%s'" % ext_flags
for eng in ['PMDK libpmem', 'PMDK dev-dax', 'libnuma']:
for line in out.decode().splitlines():
if line.startswith(eng) and 'no' in line:
self.cancel("PMEM engines not built with fio")
if not self.disk:
self.dir = self.workdir
self.target = self.disk
self.lv_disk = self.disk
self.part_obj = Partition(self.disk, mountpoint=self.dir)
self.sraid = softwareraid.SoftwareRaid(self.raid_name, '0',
self.disk.split(), '1.2')
dmesg.clear_dmesg()
if self.disk in disk.get_disks():
self.pre_cleanup()
if raid_needed:
self.create_raid(self.target, self.raid_name)
self.raid_create = True
self.target = self.raid_name
if lv_needed:
self.lv_disk = self.target
self.target = self.create_lv(self.target)
self.lv_create = True
if fstype:
self.create_fs(self.target, self.dir, fstype, fs_args,
mnt_args)
self.fs_create = True
else:
self.cancel("Missing disk %s in OS" % self.disk)
build.make(self.sourcedir, extra_args=fio_flags)
