def install_packages(self):
'''
Install necessary packages
'''
smm = SoftwareManager()
detected_distro = distro.detect()
self.log.info("Test is running on %s", detected_distro.name)
if not smm.check_installed("ksh") and not smm.install("ksh"):
self.cancel('ksh is needed for the test to be run')
if detected_distro.name == "Ubuntu":
if not smm.check_installed("python-paramiko") and not \
smm.install("python-paramiko"):
self.cancel('python-paramiko is needed for the test to be run')
ubuntu_url = self.params.get('ubuntu_url', default=None)
debs = self.params.get('debs', default=None)
if not ubuntu_url or not debs:
self.cancel("No url specified")
for deb in debs:
deb_url = os.path.join(ubuntu_url, deb)
deb_install = self.fetch_asset(deb_url, expire='7d')
shutil.copy(deb_install, self.workdir)
process.system("dpkg -i %s/%s" % (self.workdir, deb),
ignore_status=True, sudo=True)
else:
url = self.params.get('url', default=None)
if not url:
self.cancel("No url specified")
rpm_install = self.fetch_asset(url, expire='7d')
shutil.copy(rpm_install, self.workdir)
os.chdir(self.workdir)
process.run('chmod +x ibmtools')
process.run('./ibmtools --install --managed')
def setUp(self):
"""
Checking if the required packages are installed,
if not found specific packages will be installed.
"""
smm = SoftwareManager()
if not smm.check_installed("lsscsi") and not smm.install("lsscsi"):
self.cancel("Unable to install lsscsi")
self.crtl_no = self.params.get('crtl_no')
self.pci_id = self.params.get('pci_id', default="").split(",")
self.http_path = self.params.get('http_path')
self.tool_name = self.params.get('tool_name')
self.firmware_path = self.params.get('firmware_path')
self.firmware_name = self.params.get('firmware_name')
self.option = self.params.get("option")
self.option_args = self.params.get("option_args")
# Gets the list of PCIIDs on the system
cmd = 'for device in $(lspci | awk \'{print $1}\') ; do echo \
$(lspci -vmm -nn -s $device | grep "\[" | awk \'{print $NF}\' \
| sed -e "s/\]//g" | sed -e "s/\[//g" | tr \'\\n\' \' \' \
| awk \'{print $2,$3,$4,$5}\') ; done'
pci_id_formatted = []
for i in self.cmdop_list(cmd).splitlines():
pci_id_formatted.append(str(i.replace(" ", ":")))
# check if all the yaml parameters are entered
if self.crtl_no is '' or self.pci_id is '' or self.tool_name \
is '' or self.http_path is '' or self.firmware_path\
is '' or self.firmware_name is '':
self.cancel(" please ensure yaml parameters are not empty")
elif self.comp(self.pci_id, pci_id_formatted) == 1:
self.cancel(" Test skipped!!, PMC controller not available")
http_repo1 = "%s%s" % (self.firmware_path, self.firmware_name)
self.repo1 = self.fetch_asset(http_repo1, expire='10d')
self.repo1 = "%s.ufi" % self.repo1
detected_distro = distro.detect()
installed_package = "Arcconf"
if detected_distro.name == "Ubuntu":
installed_package = "arcconf"
if not smm.check_installed(installed_package):
if detected_distro.name == "Ubuntu":
http_repo = "%s%s.deb" % (self.http_path, self.tool_name)
self.repo = self.fetch_asset(http_repo, expire='10d')
cmd = "dpkg -i %s" % self.repo
else:
http_repo = "%s%s.rpm" % (self.http_path, self.tool_name)
self.repo = self.fetch_asset(http_repo, expire='10d')
cmd = "rpm -ivh %s" % self.repo
if process.system(cmd, ignore_status=True, shell=True) != 0:
self.cancel("Unable to install arcconf")
def setUp(self):
'''
set up required packages and gather necessary test inputs
'''
sm = SoftwareManager()
detected_distro = distro.detect()
self.log.info("Test is running on:" + detected_distro.name)
if not sm.check_installed("ksh") and not sm.install("ksh"):
self.error('ksh is needed for the test to be run')
if detected_distro.name == "Ubuntu":
if not sm.check_installed("python-paramiko") and not \
sm.install("python-paramiko"):
self.error('python-paramiko is needed for the test to be run')
ubuntu_url = self.params.get('ubuntu_url', default=None)
debs = self.params.get('debs', default=None)
for deb in debs:
deb_url = os.path.join(ubuntu_url, deb)
deb_install = self.fetch_asset(deb_url, expire='7d')
shutil.copy(deb_install, self.srcdir)
process.system("dpkg -i %s/%s" % (self.srcdir, deb),
ignore_status=True, sudo=True)
else:
url = self.params.get('url', default=None)
rpm_install = self.fetch_asset(url, expire='7d')
shutil.copy(rpm_install, self.srcdir)
os.chdir(self.srcdir)
process.run('chmod +x ibmtools')
process.run('./ibmtools --install --managed')
self.hmc_ip = self.params.get("hmc_ip", '*', default=None)
self.hmc_pwd = self.params.get("hmc_pwd", '*', default=None)
self.hmc_username = self.params.get("hmc_username", '*', default=None)
self.lpar_1 = self.params.get("lpar_1", '*', default=None)
self.lpar_2 = self.params.get("lpar_2", '*', default=None)
self.pci_device = self.params.get("pci_device", '*', default=None)
self.server = self.params.get("server", '*', default=None)
self.loc_code = pci.get_slot_from_sysfs(self.pci_device)
self.num_of_dlpar = int(self.params.get("num_of_dlpar", default='1'))
if self.loc_code is None:
self.cancel("Failed to get the location code for the pci device")
self.login(self.hmc_ip, self.hmc_username, self.hmc_pwd)
self.run_command("uname -a")
cmd = 'lshwres -r io -m ' + self.server + \
' --rsubtype slot --filter lpar_names=' + self.lpar_1 + \
' -F drc_index,lpar_id,drc_name | grep -i %s ' % self.loc_code
output = self.run_command(cmd)
self.drc_index = output[-1].split(',')[0]
self.lpar_id = output[-1].split(',')[1]
self.log.info("lpar_id : %s, loc_code: %s, drc_index: %s",
self.lpar_id, self.loc_code, self.drc_index)
def setUp(self):
"""
Check pre-requisites before running sensors command
Testcase should be executed only on bare-metal environment.
"""
s_mg = SoftwareManager()
d_distro = distro.detect()
if d_distro.name == "Ubuntu":
if not s_mg.check_installed("lm-sensors") and not s_mg.install(
"lm-sensors"):
self.cancel('Need sensors to run the test')
elif d_distro.name == "SuSE":
if not s_mg.check_installed("sensors") and not s_mg.install(
"sensors"):
self.cancel('Need sensors to run the test')
else:
if not s_mg.check_installed("lm_sensors") and not s_mg.install(
"lm_sensors"):
self.cancel('Need sensors to run the test')
if d_distro.arch in ["ppc64", "ppc64le"]:
if not cpu._list_matches(open('/proc/cpuinfo').readlines(),
'platform\t: PowerNV\n'):
self.cancel(
'sensors test is applicable to bare-metal environment.')
config_check = linux_modules.check_kernel_config(
'CONFIG_SENSORS_IBMPOWERNV')
if config_check == 0:
self.cancel('Config is not set')
elif config_check == 1:
if linux_modules.load_module('ibmpowernv'):
if linux_modules.module_is_loaded('ibmpowernv'):
self.log.info('Module Loaded Successfully')
else:
self.cancel('Module Loading Failed')
else:
self.log.info('Module is Built In')
if not d_distro.name == "Ubuntu":
try:
process.run('service lm_sensors stop', sudo=True)
process.run('service lm_sensors start', sudo=True)
process.run('service lm_sensors status', sudo=True)
except process.CmdError:
self.error(
'Starting Service Failed. Make sure module is loaded')
cmd = "yes | sudo sensors-detect"
det_op = process.run(cmd, shell=True, ignore_status=True).stdout
if 'no sensors were detected' in det_op:
self.cancel('No sensors found to test !')
def setUp(self):
"""
Install all the required dependencies
Building source tarball requires packages specific to os
that needs to be installed, if not installed test will stop.
"""
backend = SoftwareManager()
dist = distro.detect()
if not backend.check_installed("gcc") and not backend.install("gcc"):
self.error("gcc is needed for the test to be run")
pkgs = ['git', 'wget', 'autoconf', 'automake',
'dejagnu', 'binutils']
if dist.name == 'sles':
sles_deps = ['build', 'libdw-devel', 'libelf-devel',
'elfutils', 'binutils-devel', 'libtool', 'gcc-c++']
pkgs += sles_deps
elif dist.name in ("redhat", "fedora"):
rhel_deps = ['elfutils-devel', 'elfutils-libelf-devel',
'elfutils-libelf', 'elfutils-libs', 'libtool-ltdl']
pkgs += rhel_deps
elif dist.name == 'ubuntu':
ubuntu_deps = ['elfutils', 'libelf-dev', 'libtool',
'libelf1', 'librpmbuild3', 'binutils-dev']
pkgs += ubuntu_deps
else:
self.log.warn("Unsupported OS!")
for pkg in pkgs:
if not backend.check_installed(pkg):
if backend.install(pkg):
self.log.warn("%s installed successfully", pkg)
else:
self.error("Fail to install package- %s required for "
"this test" % pkg)
# Source: git clone git://git.debian.org/git/collab-maint/ltrace.git
git.get_repo('git://git.debian.org/git/collab-maint/ltrace.git',
destination_dir=os.path.join(self.srcdir, 'ltrace'))
self.src_lt = os.path.join(self.srcdir, "ltrace")
os.chdir(self.src_lt)
process.run('./autogen.sh')
process.run('./configure')
build.make(self.src_lt)
class Package_check(Test):
def setUp(self):
if "ppc" not in distro.detect().arch:
self.cancel("supported only on Power platform")
self.sm = SoftwareManager()
self.packages = self.params.get(
'packages', default=['powerpc-utils', 'ppc64-diag', 'lsvpd'])
if 'PowerNV' in open('/proc/cpuinfo', 'r').read():
self.packages.extend(['opal-prd'])
def test(self):
dist = distro.detect()
is_fail = 0
if dist.name == 'rhel':
packages_rhel = self.params.get(
'packages_rhel', default=['lshw', 'librtas'])
self.packages.extend(packages_rhel)
for package in self.packages:
if self.sm.check_installed("anaconda"):
self.log.info(
"%s package is installed by default" % package)
else:
self.log.info(
"%s package is not installed by default" % package)
is_fail += 1
elif dist.name == 'Ubuntu':
packages_ubuntu = self.params.get(
'packages_ubuntu', default=['librtas2'])
self.packages.extend(packages_ubuntu)
for package in self.packages:
if process.system_output("apt-mark showauto %s" % package,
shell=True):
self.log.info(
"%s package is installed by default" % package)
else:
self.log.info(
"%s package is not installed by default" % package)
is_fail += 1
else:
for package in self.packages:
if self.sm.check_installed(package):
self.log.info("%s package is installed" % package)
else:
self.log.info("%s package is not installed" % package)
if is_fail >= 1:
self.fail("%s package(s) not installed by default" % is_fail)
def setUp(self):
self.tlbflush_max_entries = self.params.get('entries', default=200)
self.tlbflush_iteration = self.params.get('iterations', default=50)
self.nr_threads = self.params.get('nr_threads', default=50)
# Check for basic utilities
smm = SoftwareManager()
if not smm.check_installed("gcc") and not smm.install("gcc"):
self.error(
"Fail to install %s required for this test." % package)
data_dir = os.path.abspath(self.datadir)
shutil.copyfile(os.path.join(data_dir, 'tlbflush.c'),
os.path.join(self.srcdir, 'tlbflush.c'))
os.chdir(self.srcdir)
os.system('cp tlbflush.c /root/pp/tlbflush.c')
tlbflush_patch = 'patch -p1 < %s' % (
os.path.join(data_dir, 'tlbflush.patch'))
process.run(tlbflush_patch, shell=True)
cmd = 'gcc -DFILE_SIZE=$((128*1048576)) -g -O2 tlbflush.c \
-lpthread -o tlbflush'
process.run(cmd, shell=True)
def setUp(self):
'''
Build Bcc Test
Source:
https://github.com/iovisor/bcc
'''
# Check for basic utilities
detected_distro = distro.detect().name.lower()
smm = SoftwareManager()
# TODO: Add support for other distributions
if not detected_distro == "ubuntu":
self.cancel("Upsupported OS %s" % detected_distro)
for package in ['bison', 'build-essential', 'cmake', 'flex',
'libedit-dev', 'libllvm3.8', 'llvm-3.8-dev',
'libclang-3.8-dev', 'python', 'zlib1g-dev',
'libelf-dev', 'clang-format-3.8', 'python-netaddr',
'python-pyroute2', 'arping', 'iperf', 'netperf',
'ethtool']:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("Failed to install %s, which is needed for"
"the test to be run" % package)
locations = ["https://github.com/iovisor/bcc/archive/master.zip"]
tarball = self.fetch_asset("bcc.zip", locations=locations,
expire='7d')
archive.extract(tarball, self.srcdir)
self.sourcedir = os.path.join(self.srcdir, 'bcc-master')
os.makedirs('%s/build' % self.sourcedir)
self.builddir = '%s/build' % self.sourcedir
os.chdir(self.builddir)
process.run('cmake .. -DCMAKE_INSTALL_PREFIX=/usr', shell=True)
build.make(self.builddir)
def setUp(self):
'''
Build interbench
Source:
http://ck.kolivas.org/apps/interbench/interbench-0.31.tar.bz2
'''
sm_manager = SoftwareManager()
for pkg in ['gcc', 'patch']:
if (not sm_manager.check_installed(pkg) and not
sm_manager.install(pkg)):
self.cancel("%s is needed for the test to be run" % pkg)
disk_free_mb = (disk.freespace(self.teststmpdir) / 1024) / 1024
if memory.memtotal()/1024 > disk_free_mb:
self.cancel('Disk space is less than total memory. Skipping test')
tarball = self.fetch_asset('http://slackware.cs.utah.edu/pub/kernel'
'.org/pub/linux/kernel/people/ck/apps/'
'interbench/interbench-0.31.tar.gz')
data_dir = os.path.abspath(self.datadir)
archive.extract(tarball, self.srcdir)
version = os.path.basename(tarball.split('.tar.')[0])
self.sourcedir = os.path.join(self.srcdir, version)
# Patch for make file
os.chdir(self.sourcedir)
makefile_patch = 'patch -p1 < %s ' % (
os.path.join(data_dir, 'makefile_fix.patch'))
process.run(makefile_patch, shell=True)
build.make(self.sourcedir)
def setUp(self):
"""
Build xfstest
Source: git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git
"""
sm = SoftwareManager()
packages = ['xfslibs-dev', 'uuid-dev', 'libtool-bin', 'e2fsprogs',
'automake', 'gcc', 'libuuid1', 'quota', 'attr',
'libattr1-dev', 'make', 'libacl1-dev', 'xfsprogs',
'libgdbm-dev', 'gawk', 'fio', 'dbench', 'uuid-runtime']
for package in packages:
if not sm.check_installed(package) and not sm.install(package):
self.error("Fail to install %s required for this test." %
package)
self.test_range = self.params.get('test_range', default=None)
if self.test_range is None:
self.fail('Please provide a test_range.')
self.skip_dangerous = self.params.get('skip_dangerous', default=True)
git.get_repo('git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git',
destination_dir=self.srcdir)
data_dir = os.path.abspath(self.datadir)
shutil.copyfile(os.path.join(data_dir, 'group'),
os.path.join(self.srcdir, 'group'))
build.make(self.srcdir)
self.available_tests = self._get_available_tests()
self.test_list = self._create_test_list()
self.log.info("Tests available in srcdir: %s",
", ".join(self.available_tests))
process.run('useradd fsgqa', sudo=True)
process.run('useradd 123456-fsgqa', sudo=True)
def setUp(self):
'''
Build linsched Test
Source:
https://github.com/thejinxters/linux-scheduler-testing
'''
# Check for basic utilities
smm = SoftwareManager()
deps = ['gcc', 'make', 'patch']
if distro.detect().name == "SuSE":
deps.append('git-core')
else:
deps.append('git')
for package in deps:
if not smm.check_installed(package) and not smm.install(package):
self.cancel(
"Fail to install %s required for this test." % package)
self.args = self.params.get('args', default='pi 100')
git.get_repo('https://github.com/thejinxters/linux-scheduler-testing',
destination_dir=self.srcdir)
os.chdir(self.srcdir)
fix_patch = 'patch -p1 < %s' % (
os.path.join(self.datadir, 'fix.patch'))
process.run(fix_patch, shell=True, ignore_status=True)
build.make(self.srcdir)
def setUp(self):
'''
Build Rmaptest
Source:
https://www.kernel.org/pub/linux/kernel/people/mbligh/tools/rmap-test.c
'''
# Check for basic utilities
smm = SoftwareManager()
if not smm.check_installed("gcc") and not smm.install("gcc"):
self.error('Gcc is needed for the test to be run')
rmaptest = self.fetch_asset('https://www.kernel.org/pub/'
'linux/kernel/people/mbligh/'
'tools/rmap-test.c', expire='7d')
shutil.copyfile(rmaptest, os.path.join(self.workdir, 'rmap-test.c'))
os.chdir(self.workdir)
if 'CC' in os.environ:
cc = '$CC'
else:
cc = 'cc'
process.system('%s -Wall -o rmaptest rmap-test.c' %
cc, ignore_status=True)
def setUp(self):
'''
check the availability of perftest package installed
perftest package should be installed
'''
sm = SoftwareManager()
depends = ["openssh-clients", "perftest"]
for pkg in depends:
if not sm.check_installed(pkg) and not sm.install(pkg):
self.skip("%s package is need to test" % pkg)
interfaces = netifaces.interfaces()
self.flag = self.params.get("ext_flag", default="0")
self.IF = self.params.get("Iface", default="")
self.PEER_IP = self.params.get("PEERIP", default="")
if self.IF not in interfaces:
self.skip("%s interface is not available" % self.IF)
if self.PEER_IP == "":
self.skip("%s peer machine is not available" % self.PEER_IP)
self.CA = self.params.get("CA_NAME", default="mlx4_0")
self.PORT = self.params.get("PORT_NUM", default="1")
self.PEER_CA = self.params.get("PEERCA", default="mlx4_0")
self.PEER_PORT = self.params.get("PEERPORT", default="1")
self.to = self.params.get("timeout", default="600")
self.tool_name = self.params.get("tool", default="")
if self.tool_name == "":
self.skip("should specify tool name")
self.log.info("test with %s" % (self.tool_name))
self.test_op = self.params.get("test_opt", default="").split(",")
self.ext_test_op = self.params.get("ext_opt", default="").split(",")
def setUp(self):
"""
Build 'fio and ezfio'.
"""
self.disk = self.params.get('disk', default='/dev/nvme0n1')
cmd = 'ls %s' % self.disk
if process.system(cmd, ignore_status=True) is not 0:
self.cancel("%s does not exist" % self.disk)
fio_path = os.path.join(self.teststmpdir, 'fio')
fio_link = 'https://github.com/axboe/fio.git'
git.get_repo(fio_link, destination_dir=fio_path)
build.make(fio_path, make='./configure')
build.make(fio_path)
build.make(fio_path, extra_args='install')
self.ezfio_path = os.path.join(self.teststmpdir, 'ezfio')
ezfio_link = 'https://github.com/earlephilhower/ezfio.git'
git.get_repo(ezfio_link, destination_dir=self.ezfio_path)
self.utilization = self.params.get('utilization', default='100')
# aio-max-nr is 65536 by default, and test fails if QD is 256 or above
genio.write_file("/proc/sys/fs/aio-max-nr", "1048576")
smm = SoftwareManager()
# Not a package that must be installed, so not skipping.
if not smm.check_installed("sdparm") and not smm.install("sdparm"):
self.log.debug("Can not install sdparm")
self.cwd = os.getcwd()
def setUp(self):
'''
Install the basic packages to support perf
'''
# Check for basic utilities
smm = SoftwareManager()
detected_distro = distro.detect()
kernel_ver = platform.uname()[2]
deps = ['gcc', 'make']
if 'Ubuntu' in detected_distro.name:
deps.extend(['linux-tools-common', 'linux-tools-%s' % kernel_ver])
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
elif detected_distro.name in ['rhel', 'SuSE', 'fedora', 'centos', 'redhat']:
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)
locations = ["https://github.com/rfmvh/perftool-testsuite/archive/"
"master.zip"]
tarball = self.fetch_asset("perftool.zip", locations=locations,
expire='7d')
archive.extract(tarball, self.srcdir)
self.sourcedir = os.path.join(self.srcdir, 'perftool-testsuite-master')
def setUp(self):
'''
Build FileBench
Source:
https://github.com/filebench/filebench/releases/download/1.5-alpha3/filebench-1.5-alpha3.tar.gz
'''
# Check for basic utilities
smm = SoftwareManager()
deps = ['libtool', 'automake', 'autoconf', 'bison', 'gcc', 'flex']
for package in deps:
if not smm.check_installed(package) and not smm.install(package):
self.error(package + ' is needed for the test to be run')
self._testfile = self.params.get('testfile', default='fileserver.f')
tarball = self.fetch_asset('https://github.com/filebench/'
'filebench/releases/ownload/1.5-alpha3/'
'filebench-1.5-alpha3.tar.gz', expire='7d')
archive.extract(tarball, self.srcdir)
version = os.path.basename(tarball.split('.tar.')[0])
self.srcdir = os.path.join(self.srcdir, version)
os.chdir(self.srcdir)
process.run('./configure', shell=True, sudo=True)
build.make(self.srcdir)
build.make(self.srcdir, extra_args='install')
# Setup test file
t_dir = '/usr/local/share/filebench/workloads/'
shutil.copyfile(os.path.join(t_dir, self._testfile),
os.path.join(self.srcdir, self._testfile))
def setUp(self):
smm = SoftwareManager()
self.minthreads = self.params.get(
'minthrd', default=(500 + cpu.online_cpus_count()))
self.maxthreads = self.params.get('maxthrd', default=None)
self.iothreads = self.params.get('iothrd', default=self.minthreads/2)
self.maxmem = self.params.get('maxmem', default=int(
memory.meminfo.MemFree.m / self.minthreads))
self.maxio = self.params.get('maxio', default=None)
self.longthreads = self.params.get('longthrd', default=False)
self.shrtthreads = self.params.get('shortthrd', default=False)
self.time = self.params.get('time', default=100)
self.iotime = self.params.get('iotime', default=50)
if self.longthreads and self.shrtthreads:
self.cancel('Please choose right inputs')
dist = distro.detect()
packages = ['gcc']
if dist.name == 'Ubuntu':
packages.extend(['g++'])
elif dist.name in ['SuSE', 'fedora', 'rhel']:
packages.extend(['gcc-c++'])
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)
for file_name in ['dwh.cpp', 'Makefile']:
self.copyutil(file_name)
os.chdir(self.teststmpdir)
if dist.name in ['fedora', 'rhel']:
process.system('patch -p0 < %s' %
self.get_data('fofd.patch'), shell=True)
build.make(self.teststmpdir)
def setUp(self):
'''
Build ebizzy
Source:
http://liquidtelecom.dl.sourceforge.net/project/ebizzy/ebizzy/0.3
/ebizzy-0.3.tar.gz
'''
sm = SoftwareManager()
if not sm.check_installed("gcc") and not sm.install("gcc"):
self.error("Gcc is needed for the test to be run")
tarball = self.fetch_asset('http://liquidtelecom.dl.sourceforge.net'
'/project/ebizzy/ebizzy/0.3'
'/ebizzy-0.3.tar.gz')
data_dir = os.path.abspath(self.datadir)
archive.extract(tarball, self.srcdir)
version = os.path.basename(tarball.split('.tar.')[0])
self.srcdir = os.path.join(self.srcdir, version)
patch = self.params.get(
'patch', default='Fix-build-issues-with-ebizzy.patch')
os.chdir(self.srcdir)
p1 = 'patch -p0 < %s/%s' % (data_dir, patch)
process.run(p1, shell=True)
process.run('[ -x configure ] && ./configure', shell=True)
build.make(self.srcdir)
def setUp(self):
'''
Build numatop Test
Source:
https://github.com/01org/numatop.git
'''
# Check for basic utilities
# TODO: Add support for other distributions
self.numa_pid = None
detected_distro = distro.detect().name.lower()
if not detected_distro == "ubuntu":
self.cancel("Upsupported OS %s" % detected_distro)
smm = SoftwareManager()
for package in ['gcc', 'numatop', 'make', 'libnuma-dev']:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("Failed to install %s, which is needed for"
"the test to be run" % package)
locations = ["https://github.com/01org/numatop/archive/master.zip"]
tarball = self.fetch_asset("numatop.zip", locations=locations,
expire='7d')
archive.extract(tarball, self.srcdir)
self.sourcedir = os.path.join(self.srcdir, 'numatop-master')
os.chdir(self.sourcedir)
build.make(self.sourcedir, extra_args='test')
def setUp(self):
'''
Install the basic packages to support perf
'''
# Check for basic utilities
smm = SoftwareManager()
detected_distro = distro.detect()
self.distro_name = detected_distro.name
deps = ['gcc', 'make']
if 'Ubuntu' in self.distro_name:
deps.extend(['linux-tools-common', 'linux-tools-%s' %
platform.uname()[2]])
elif self.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)
shutil.copyfile(self.get_data('uprobe.c'),
os.path.join(self.teststmpdir, 'uprobe.c'))
shutil.copyfile(self.get_data('Makefile'),
os.path.join(self.teststmpdir, 'Makefile'))
build.make(self.teststmpdir)
os.chdir(self.teststmpdir)
self.temp_file = tempfile.NamedTemporaryFile().name
self.cmdProbe = "perf probe -x"
self.recProbe = "perf record -o %s -e probe_uprobe_test:doit" % self.temp_file
self.report = "perf report --input=%s" % self.temp_file
self.distro_version = detected_distro.version
def setUp(self):
'''
Use 85% of memory with/without many process forked
WARNING: System may go out-of-memory based on the available resource
'''
smm = SoftwareManager()
self.itern = int(self.params.get('iterations', default='10'))
self.procs = int(self.params.get('procs', default='1'))
self.minmem = int(self.params.get('minmem', default='10'))
self.fails = []
if not (self.itern and self.procs and self.minmem):
self.cancel(
'Please use a non-zero value for number'
' of iterations, processes and memory to be used')
self.freemem = int((0.85 * memory.freememtotal()) / 1024)
# Check for basic utilities
for packages in ['gcc', 'make']:
if not smm.check_installed(packages) and not smm.install(packages):
self.cancel('%s is needed for the test to be run' % packages)
shutil.copyfile(self.get_data('forkoff.c'),
os.path.join(self.teststmpdir, 'forkoff.c'))
shutil.copyfile(self.get_data('Makefile'),
os.path.join(self.teststmpdir, 'Makefile'))
build.make(self.teststmpdir)
def setUp(self):
'''
Build Hackbench
Source:
http://people.redhat.com/~mingo/cfs-scheduler/tools/hackbench.c
'''
self._threshold_time = self.params.get('time_val', default=None)
self._num_groups = self.params.get('num_groups', default=90)
self._iterations = self.params.get('iterations', default=1)
self.results = None
sm = SoftwareManager()
if not sm.check_installed("gcc") and not sm.install("gcc"):
self.cancel("Gcc is needed for the test to be run")
hackbench = self.fetch_asset('http://people.redhat.com'
'/~mingo/cfs-scheduler/'
'tools/hackbench.c')
shutil.copyfile(hackbench, os.path.join(self.workdir, 'hackbench.c'))
os.chdir(self.workdir)
if 'CC' in os.environ:
cc = '$CC'
else:
cc = 'cc'
process.system('%s hackbench.c -o hackbench -lpthread' % cc)
def setUp(self):
"""
Checking if the required packages are installed,
if not found packages will be installed
"""
smm = SoftwareManager()
if not smm.check_installed("mdadm"):
print "Mdadm must be installed before continuing the test"
if SoftwareManager().install("mdadm") is False:
self.cancel("Unable to install mdadm")
cmd = "mdadm -V"
self.check_pass(cmd, "Unable to get mdadm version")
self.disk = self.params.get('disks', default='').strip(" ")
self.raidlevel = str(self.params.get('raid', default='0'))
self.metadata = str(self.params.get('metadata', default='1.2'))
self.setup = self.params.get('setup', default=True)
self.run_test = self.params.get('run_test', default=False)
self.cleanup = self.params.get('cleanup', default=True)
self.sparedisk = ""
if self.raidlevel == 'linear' or self.raidlevel == '0':
self.disk_count = len(self.disk.split(" "))
else:
self.disk = self.disk.split(" ")
self.sparedisk = self.disk.pop()
self.remadd = ''.join(self.disk[-1:])
self.disk_count = len(self.disk)
self.disk = ' '.join(self.disk)
self.force = self.params.get('force', default=False)
def setUp(self):
'''
Build FileBench
Source:
https://github.com/filebench/filebench/releases/download/1.5-alpha3/filebench-1.5-alpha3.tar.gz
'''
# Check for basic utilities
smm = SoftwareManager()
deps = ['libtool', 'automake', 'autoconf', 'bison', 'gcc', 'flex']
for package in deps:
if not smm.check_installed(package) and not smm.install(package):
self.cancel(package + ' is needed for the test to be run')
name_version = 'filebench-1.5-alpha3'
tarball = self.fetch_asset('https://github.com/filebench/'
'filebench/releases/download/1.5-alpha3/'
'%s.tar.gz' % name_version)
archive.extract(tarball, self.workdir)
self.install_prefix = os.path.join(self.workdir, 'install_prefix')
build_dir = os.path.join(self.workdir, name_version)
os.chdir(build_dir)
process.run('./configure --prefix=%s' % self.install_prefix,
shell=True)
build.make(build_dir)
build.make(build_dir, extra_args='install')
def setUp(self):
if not memory.check_hotplug():
self.cancel("UnSupported : memory hotplug not enabled\n")
sm = SoftwareManager()
if not sm.check_installed('stress') and not sm.install('stress'):
tarball = self.fetch_asset(
'https://people.seas.harvard.edu/~apw/stress/stress-1.0.4.tar.gz')
archive.extract(tarball, self.teststmpdir)
self.sourcedir = os.path.join(
self.teststmpdir, os.path.basename(tarball.split('.tar.')[0]))
os.chdir(self.sourcedir)
process.run('[ -x configure ] && ./configure', shell=True)
build.make(self.sourcedir)
build.make(self.sourcedir, extra_args='install')
self.iteration = self.params.get('iteration', default=1)
self.stresstime = self.params.get('stresstime', default=10)
self.vmcount = self.params.get('vmcount', default=4)
self.iocount = self.params.get('iocount', default=4)
self.memratio = self.params.get('memratio', default=5)
self.blocks_hotpluggable = get_hotpluggable_blocks(
(os.path.join('%s', 'memory*') % mem_path), self.memratio)
if os.path.exists("%s/auto_online_blocks" % mem_path):
if not self.__is_auto_online():
self.hotplug_all(self.blocks_hotpluggable)
clear_dmesg()
def setUp(self):
'''
Build Connectathon
Source:
git://git.linux-nfs.org/projects/steved/cthon04.git
'''
self.nfail = 0
# Check for root permission
if os.geteuid() != 0:
exit("You need to have root privileges to run this script."
"\nPlease try again, using 'sudo'. Exiting.")
# Check for basic utilities
smm = SoftwareManager()
detected_distro = distro.detect()
packages = ['gcc', 'make']
if detected_distro.name == "SuSE":
packages.extend(['git-core'])
else:
packages.extend(['git'])
for package in packages:
if not smm.check_installed(package) and not smm.install(package):
self.error("Fail to install %s required for this test." %
package)
self.tmpdir = tempfile.mkdtemp(prefix='avocado_' + __name__)
data_dir = os.path.abspath(self.datadir)
git.get_repo('git://git.linux-nfs.org/projects/steved/cthon04.git',
destination_dir=self.srcdir)
os.chdir(self.srcdir)
build.make(self.srcdir)
def setUp(self):
'''
Build IOZone
Source:
http://www.iozone.org/src/current/iozone3_434.tar
'''
self.base_dir = os.path.abspath(self.basedir)
smm = SoftwareManager()
for package in ['gcc', 'make', 'patch']:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("%s is needed for the test to be run" % package)
tarball = self.fetch_asset(
'http://www.iozone.org/src/current/iozone3_434.tar')
archive.extract(tarball, self.teststmpdir)
version = os.path.basename(tarball.split('.tar')[0])
self.sourcedir = os.path.join(self.teststmpdir, version)
make_dir = os.path.join(self.sourcedir, 'src', 'current')
os.chdir(make_dir)
patch = self.params.get('patch', default='makefile.patch')
patch = os.path.join(self.datadir, patch)
process.run('patch -p3 < %s' % patch, shell=True)
d_distro = distro.detect()
arch = d_distro.arch
if arch == 'ppc':
build.make(make_dir, extra_args='linux-powerpc')
elif arch == 'ppc64' or arch == 'ppc64le':
build.make(make_dir, extra_args='linux-powerpc64')
elif arch == 'x86_64':
build.make(make_dir, extra_args='linux-AMD64')
else:
build.make(make_dir, extra_args='linux')
def setUp(self):
"""
Download 'nvme-cli'.
"""
self.device = self.params.get('device', default='/dev/nvme0')
self.disk = self.params.get('disk', default='/dev/nvme0n1')
cmd = 'ls %s' % self.device
if process.system(cmd, ignore_status=True) is not 0:
self.skip("%s does not exist" % self.device)
smm = SoftwareManager()
if not smm.check_installed("nvme-cli") and not \
smm.install("nvme-cli"):
self.skip('nvme-cli is needed for the test to be run')
python_packages = pip.get_installed_distributions()
python_packages_list = [i.key for i in python_packages]
python_pkgs = ['nose', 'nose2', 'pep8', 'flake8', 'pylint', 'epydoc']
for py_pkg in python_pkgs:
if py_pkg not in python_packages_list:
self.skip("python package %s not installed" % py_pkg)
url = 'https://codeload.github.com/linux-nvme/nvme-cli/zip/master'
tarball = self.fetch_asset("nvme-cli-master.zip", locations=[url],
expire='7d')
archive.extract(tarball, self.teststmpdir)
self.nvme_dir = os.path.join(self.teststmpdir, "nvme-cli-master")
print os.listdir(self.nvme_dir)
os.chdir(os.path.join(self.nvme_dir, 'tests'))
msg = ['{']
msg.append(' \"controller\": \"%s\",' % self.device)
msg.append(' \"ns1\": \"%s\",' % self.disk)
msg.append(' \"log_dir\": \"%s\"' % self.outputdir)
msg.append('}')
with open('config.json', 'w') as config_file:
config_file.write("\n".join(msg))
process.system("cat config.json")
def setUp(self):
'''
Build Stutter Test
Source:
https://github.com/gaowanlong/stutter/archive/master.zip
'''
# Check for basic utilities
smm = SoftwareManager()
if not smm.check_installed("gcc") and not smm.install("gcc"):
self.error('Gcc is needed for the test to be run')
locations = ["https://github.com/gaowanlong/stutter/archive/"
"master.zip"]
tarball = self.fetch_asset("stutter.zip", locations=locations,
expire='7d')
archive.extract(tarball, self.srcdir)
self.srcdir = os.path.join(self.srcdir, 'stutter-master')
mem_byte = str(memory.memtotal())
print mem_byte
self._memory = self.params.get('memory', default=mem_byte)
self._iteration = self.params.get('iteration', default='10')
self._logdir = self.params.get('logdir', default='/var/tmp/logdir')
self._rundir = self.params.get('rundir', default='/tmp')
process.run('mkdir -p %s' % self._logdir)
# export env variable, used by test script
os.environ['MEMTOTAL_BYTES'] = self._memory
os.environ['ITERATIONS'] = self._iteration
os.environ['LOGDIR_RESULTS'] = self._logdir
os.environ['TESTDISK_DIR'] = self._rundir
build.make(self.srcdir)
def setUp(self):
self.test_file = self.params.get('tmp_file', default='/tmp/dummy')
self.duration = self.params.get('duration', default='30')
self.threads = self.params.get(
'threads', default=cpu.online_cpus_count())
self.size = self.params.get(
'memory_to_test', default=int(0.9 * memory.meminfo.MemFree.m))
smm = SoftwareManager()
for package in ['gcc', 'libtool', 'autoconf', 'automake', 'make']:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("Failed to install %s, which is needed for"
"the test to be run" % package)
if not os.path.exists(self.test_file):
try:
os.mknod(self.test_file)
except OSError:
self.cancel("Skipping test since test file creation failed")
loc = ["https://github.com/stressapptest/"
"stressapptest/archive/master.zip"]
tarball = self.fetch_asset("stressapp.zip", locations=loc,
expire='7d')
archive.extract(tarball, self.workdir)
self.sourcedir = os.path.join(self.workdir, 'stressapptest-master')
os.chdir(self.sourcedir)
process.run('./configure', shell=True)
build.make(self.sourcedir)
def setUp(self):
'''
To check and install dependencies for the test
'''
sm = SoftwareManager()
for pkg in ["ethtool", "net-tools"]:
if not sm.check_installed(pkg) and not sm.install(pkg):
self.cancel("%s package is need to test" % pkg)
interfaces = netifaces.interfaces()
self.iface = self.params.get("interface")
if self.iface not in interfaces:
self.cancel("%s interface is not available" % self.iface)
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
configure_network.set_ip(self.ipaddr, self.netmask, self.iface)
cmd = "basename /sys/class/net/%s/device/driver/module/drivers/*" % self.iface
self.iface_type, self.driver = process.system_output(
cmd, shell=True).decode("utf-8").split(':')
self.businfo = self.get_bus_info(self.iface, self.iface_type)
def setUp(self):
"""
Build bonnie++
Source:
http://www.coker.com.au/bonnie++/experimental/bonnie++-1.03e.tgz
"""
fstype = self.params.get('fs', default='ext4')
smm = SoftwareManager()
if fstype == 'btrfs':
if distro.detect().name == 'Ubuntu':
if not smm.check_installed("btrfs-tools") and not \
smm.install("btrfs-tools"):
self.cancel('btrfs-tools is needed for the test to be run')
self.disk = self.params.get('disk', default=None)
self.scratch_dir = self.params.get('dir', default=self.srcdir)
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)
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)
if self.disk is not None:
self.part_obj = Partition(self.disk, mountpoint=self.scratch_dir)
self.log.info("Test will run on %s", self.scratch_dir)
self.log.info("Unmounting disk/dir before creating file system")
self.part_obj.unmount()
self.log.info("creating %s file system on %s disk", fstype,
self.disk)
self.part_obj.mkfs(fstype)
self.log.info("Mounting disk %s on directory %s", self.disk,
self.scratch_dir)
self.part_obj.mount()
def setUp(self):
"""
Build libvecpf
Source:
http://github.com/Libvecpf/libvecpf.git
"""
smm = SoftwareManager()
for package in ['gcc', 'make']:
if not smm.check_installed(package) and not smm.install(package):
self.cancel('%s is needed for the test to be run' % package)
tarball = self.fetch_asset('libvecpf.zip', locations=[
'https://github.com/Libvecpf/libvecpf'
'/archive/master.zip'], expire='7d')
archive.extract(tarball, self.workdir)
self.sourcedir = os.path.join(self.workdir, 'libvecpf-master')
build.make(self.sourcedir, make='./configure')
build.make(self.sourcedir)
def setUp(self):
'''
To check and install dependencies for the test
'''
sm = SoftwareManager()
network_tools = ("iputils", "ethtool", "net-tools", "openssh-clients")
for pkg in network_tools:
if not sm.check_installed(pkg) and not sm.install(pkg):
self.skip("%s package is need to test" % pkg)
interfaces = netifaces.interfaces()
interface = self.params.get("iface")
if interface not in interfaces:
self.skip("%s interface is not available" % interface)
mtu_list = self.params.get("size_val", default=1500)
self.mtu_list = mtu_list.split()
self.interface = interface
self.peer = self.params.get("peerip")
self.eth = "ethtool %s | grep 'Link detected:'" % self.interface
self.eth_state = process.system_output(self.eth, shell=True)
def setUp(self):
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
if distro.detect().name in ['rhel', 'redhat']:
self.cancel('Hwinfo not supported on RHEL')
sm = SoftwareManager()
if not sm.check_installed("hwinfo") and not sm.install("hwinfo"):
self.cancel("Fail to install hwinfo required for this test.")
self.clear_dmesg()
self.disk_name = process.system_output(
"df -h | egrep '(s|v)d[a-z][1-8]' | "
"tail -1 | cut -d' ' -f1",
shell=True).strip("12345")
self.Unique_Id = process.system_output("hwinfo --disk --only %s | "
"grep 'Unique' | head -1 | "
"cut -d':' -f2" %
self.disk_name,
shell=True)
def setUp(self):
"""
Verifies if we have gcc to compile disktest.
:param disk: Disk to be used in test.
:param dir: Directory of used in test. When the target does not exist,
it's created.
:param gigabytes: Disk space that will be used for the test to run.
:param chunk_mb: Size of the portion of the disk used to run the test.
Cannot be smaller than the total amount of RAM.
"""
softm = SoftwareManager()
if not softm.check_installed("gcc") and not softm.install("gcc"):
self.cancel('Gcc is needed for the test to be run')
# Log of all the disktest processes
self.disk_log = os.path.abspath(os.path.join(self.outputdir,
"log.txt"))
self._init_params()
self._compile_disktest()
def setUp(self):
# Check for basic utilities
sm = SoftwareManager()
detected_distro = distro.detect()
deps = ['oprofile', 'dejagnu', 'expect']
if detected_distro.name == "SuSE":
deps.append("git-core")
else:
deps.append("git")
if detected_distro.name == "Ubuntu":
deps.append("libxml2-utils")
deps.append("tclsh")
for package in deps:
if not sm.check_installed(package) and not sm.install(package):
self.error(package + ' is needed for the test to be run')
git.get_repo('git://git.code.sf.net/p/oprofile/oprofile-tests',
destination_dir=self.srcdir)
os.chdir(self.srcdir)
os.chdir("testsuite/")
def setUp(self):
'''
Build Trinity
Source:
https://github.com/kernelslacker/trinity
'''
"""
Add not root user
"""
if process.system('getent group trinity', ignore_status=True):
process.run('groupadd trinity', sudo=True)
if process.system('getent passwd trinity', ignore_status=True):
process.run('useradd -g trinity -m -d /home/trinity trinity',
sudo=True)
process.run('usermod -a -G trinity trinity', sudo=True)
smm = SoftwareManager()
for package in ("gcc", "make"):
if not smm.check_installed(package) and not smm.install(package):
self.error("Fail to install %s required for this test." %
package)
locations = [
"https://github.com/kernelslacker/trinity/archive/"
"master.zip"
]
tarball = self.fetch_asset("trinity.zip",
locations=locations,
expire='7d')
archive.extract(tarball, self.srcdir)
self.srcdir = os.path.join(self.srcdir, 'trinity-master')
os.chdir(self.srcdir)
process.run('chmod -R +x ' + self.srcdir)
process.run('./configure', shell=True)
build.make('.')
process.run('touch trinity.log')
process.run('cp -r ' + self.srcdir + ' /home/trinity')
self.srcdir = os.path.join('/home/trinity', 'trinity-master')
process.run('chown -R trinity:trinity ' + self.srcdir)
def setUp(self):
'''
Install the basic packages to support perf
'''
# Check for basic utilities
smm = SoftwareManager()
detected_distro = distro.detect()
self.distro_name = detected_distro.name
deps = ['gcc', 'make']
if 'Ubuntu' in self.distro_name:
deps.extend(
['linux-tools-common',
'linux-tools-%s' % platform.uname()[2]])
elif 'debian' in detected_distro.name:
deps.extend(['linux-perf'])
elif self.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)
# Check for c2c is available in the system.
output = process.run('perf mem record -e list').stderr.decode("utf-8")
if 'ldlat-stores' in output or 'ldlat-loads' in output:
self.log.info("perf c2c is available")
else:
self.cancel('perf c2c is not available')
# Creating temporary file to collect the perf.data
self.temp_file = tempfile.NamedTemporaryFile().name
# Getting the parameters from yaml file
self.record = self.params.get('record_method', default='')
self.report = self.params.get('report_method', default='')
# Clear the dmesg, by that we can capture the delta at the end of the
# test.
process.run("dmesg -C", sudo=True)
def setUp(self):
"""
Verify it is baremetal
Install the cpupower tool
:avocado: tags=cpu,power
"""
if not os.path.exists('/proc/device-tree/ibm,opal/power-mgt'):
self.cancel("Supported only on Power Non Virutalized environment")
smm = SoftwareManager()
detected_distro = distro.detect()
if 'Ubuntu' in detected_distro.name:
deps = ['linux-tools-common', 'linux-tools-%s'
% platform.uname()[2]]
else:
deps = ['kernel-tools']
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)
def setUp(self):
'''
Build posixtest
Source:
http://ufpr.dl.sourceforge.net/sourceforge/posixtest/posixtestsuite-1.5.2.tar.gz
'''
self.test_type = self.params.get('test_type', default='THR')
sm = SoftwareManager()
for package in ['gcc', 'make']:
if not sm.check_installed(package) and not sm.install(package):
self.cancel("%s is needed for the test to be run" % package)
tarball = self.fetch_asset("http://ufpr.dl.sourceforge.net"
"/sourceforge/posixtest"
"/posixtestsuite-1.5.2.tar.gz")
archive.extract(tarball, self.workdir)
version = os.path.basename(tarball.split('-1.')[0])
self.sourcedir = os.path.join(self.workdir, version)
build.make(self.sourcedir)
def setUp(self):
smg = SoftwareManager()
dist = distro.detect()
if dist.name in ['Ubuntu']:
linux_tools = "linux-tools-" + os.uname()[2]
pkgs = [linux_tools]
if dist.name in ['Ubuntu']:
pkgs.extend(['linux-tools-common'])
elif dist.name in ['debian']:
pkgs = ['linux-perf']
elif dist.name in ['centos', 'fedora', 'rhel', 'SuSE']:
pkgs = ['perf']
else:
self.cancel("perf is not supported on %s" % dist.name)
for pkg in pkgs:
if not smg.check_installed(pkg) and not smg.install(pkg):
self.cancel("Package %s is missing/could not be installed" %
pkg)
def setUp(self):
if "ppc" not in os.uname()[4]:
self.cancel("supported only on Power platform")
smm = SoftwareManager()
detected_distro = distro.detect()
parser = configparser.ConfigParser()
parser.read(self.get_data("pvr.cfg"))
if detected_distro.name == "Ubuntu":
pkg = 'device-tree-compiler'
else:
pkg = 'dtc'
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is needed for the test to be run" % pkg)
val = genio.read_file("/proc/cpuinfo")
for line in val.splitlines():
if 'revision' in line:
rev = (line.split('revision')[1]).split()
self.log.info("Revision: %s %s" % (rev, rev[1]))
break
if 'pSeries|PowerNV' in val and 'POWER8' in val:
self.pvr_value = parser.get('PVR_Values', 'pvr_value_p8')
elif 'pSeries' in val and 'POWER9' in val:
if (rev[1] == '1.2'):
self.pvr_value = parser.get('PVR_Values', 'pvr_value_p9LPAR_1.2')
elif (rev[1] == '2.2'):
self.pvr_value = parser.get('PVR_Values', 'pvr_value_p9LPAR_2.2')
elif (rev[1] == '2.3'):
self.pvr_value = parser.get('PVR_Values', 'pvr_value_p9LPAR_2.3')
elif 'PowerNV' in val and 'POWER9' in val:
if (rev[1] == '2.1'):
self.pvr_value = parser.get('PVR_Values', 'pvr_value_p9NV_2.1')
elif (rev[1] == '2.2'):
self.pvr_value = parser.get('PVR_Values', 'pvr_value_p9NV_2.2')
elif (rev[1] == '2.3'):
self.pvr_value = parser.get('PVR_Values', 'pvr_value_p9NV_2.3')
elif 'pSeries' in val and 'POWER10' in val:
if (rev[1] == '1.0'):
self.pvr_value = parser.get('PVR_Values', 'pvr_value_p10_1')
elif (rev[1] == '2.0'):
self.pvr_value = parser.get('PVR_Values', 'pvr_value_p10_2')
else:
self.fail("Unsupported processor family")
def setUp(self):
smm = SoftwareManager()
deps = ['gcc', 'make', 'patch']
for package in deps:
if not smm.check_installed(package) and not smm.install(package):
self.cancel(package + ' is needed for the test to be run')
url = 'https://github.com/julman99/eatmemory/archive/master.zip'
tarball = self.fetch_asset("eatmemory.zip", locations=[url], expire='7d')
archive.extract(tarball, self.workdir)
self.sourcedir = os.path.join(self.workdir, "eatmemory-master")
# patch for getch remove
getch_patch = 'patch -p1 < %s' % self.get_data('eatmem_getch.patch')
os.chdir(self.sourcedir)
process.run(getch_patch, shell=True)
build.make(self.sourcedir)
mem = self.params.get('memory_to_test', default=int(0.95 * memory.meminfo.MemFree.k))
self.mem_to_eat = self._mem_to_mbytes(mem)
if self.mem_to_eat is None:
self.cancel("Memory '%s' not valid." % mem)
def setup_htx(self):
"""
Builds HTX
"""
detected_distro = distro.detect()
packages = ['git', 'gcc', 'make']
if detected_distro.name in ['centos', 'fedora', 'rhel', 'redhat']:
packages.extend(['gcc-c++', 'ncurses-devel', 'tar'])
elif detected_distro.name == "Ubuntu":
packages.extend(
['libncurses5', 'g++', 'ncurses-dev', 'libncurses-dev'])
elif detected_distro.name == 'SuSE':
packages.extend(['libncurses5', 'gcc-c++', 'ncurses-devel', 'tar'])
else:
self.cancel("Test not supported in %s" % detected_distro.name)
smm = SoftwareManager()
for pkg in packages:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("Can not install %s" % pkg)
url = "https://github.com/open-power/HTX/archive/master.zip"
tarball = self.fetch_asset("htx.zip", locations=[url], expire='7d')
archive.extract(tarball, self.teststmpdir)
htx_path = os.path.join(self.teststmpdir, "HTX-master")
os.chdir(htx_path)
exercisers = ["hxecapi_afu_dir", "hxedapl", "hxecapi", "hxeocapi"]
for exerciser in exercisers:
process.run("sed -i 's/%s//g' %s/bin/Makefile" %
(exerciser, htx_path))
build.make(htx_path, extra_args='all')
build.make(htx_path, extra_args='tar')
process.run('tar --touch -xvzf htx_package.tar.gz')
os.chdir('htx_package')
if process.system('./installer.sh -f'):
self.fail("Installation of htx fails:please refer job.log")
self.log.info("Starting the HTX Deamon")
process.run('/usr/lpp/htx/etc/scripts/htxd_run')
self.log.info("Creating the HTX mdt files")
process.run('htxcmdline -createmdt')
def setUp(self):
dist = distro.detect()
sm = SoftwareManager()
sos_pkg = ""
if not process.system("sosreport", ignore_status=True, sudo=True):
self.log.info("sosreport is installed")
elif dist.name == 'Ubuntu':
sos_pkg = 'sosreport'
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
elif dist.name in ['rhel', 'redhat']:
sos_pkg = 'sos'
else:
self.cancel("sosreport is not supported on this distro ")
if sos_pkg and not sm.check_installed(sos_pkg) and not sm.install(
sos_pkg):
self.cancel("Package %s is missing and could not be installed" %
sos_pkg)
def setUp(self):
'''
Build Stutter Test
Source:
https://github.com/gaowanlong/stutter/archive/master.zip
'''
# Check for basic utilities
smm = SoftwareManager()
for package in ['gcc', 'make']:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("Fail to install %s required for this test." %
package)
locations = [
"https://github.com/gaowanlong/stutter/archive/"
"master.zip"
]
tarball = self.fetch_asset("stutter.zip",
locations=locations,
expire='7d')
archive.extract(tarball, self.workdir)
self.sourcedir = os.path.join(self.workdir, 'stutter-master')
mem_byte = str(memory.memtotal())
print mem_byte
self._memory = self.params.get('memory', default=mem_byte)
self._iteration = self.params.get('iteration', default='10')
self._logdir = self.params.get('logdir', default='/var/tmp/logdir')
self._rundir = self.params.get('rundir', default='/tmp')
if not os.path.exists(self._logdir):
os.makedirs(self._logdir)
# export env variable, used by test script
os.environ['MEMTOTAL_BYTES'] = self._memory
os.environ['ITERATIONS'] = self._iteration
os.environ['LOGDIR_RESULTS'] = self._logdir
os.environ['TESTDISK_DIR'] = self._rundir
build.make(self.sourcedir)
def setUp(self):
"""
Install all the dependency packages required for building
source tarball specific to os,if not tests will stop.
"""
smm = SoftwareManager()
dist = distro.detect()
packages = ['gcc', 'dejagnu', 'flex', 'bison', 'sharutils']
if dist.name in ['Ubuntu', 'debian']:
packages.extend(['libmpfr-dev', 'libgmp-dev', 'libmpc-dev',
'zip', 'libc6-dev', 'libelf1',
'elfutils', 'autogen'])
if dist.name == 'Ubuntu':
packages.extend(['texinfo', 'gnat'])
elif dist.name == 'SuSE':
packages.extend(['glibc-devel-static', 'zlib-devel', 'elfutils',
'libelf-devel', 'gcc-c++', 'isl-devel',
'gmp-devel', 'glibc-devel', 'mpfr-devel',
'makeinfo', 'texinfo', 'mpc-devel'])
else:
packages.extend(['glibc-static', 'autogen', 'guile',
'guile-devel', 'libgo', 'libgo-devel',
'libgo-static', 'elfutils-devel',
'texinfo-tex', 'texinfo', 'elfutils-libelf-devel',
'gmp-devel', 'mpfr-devel', 'libmpc-devel',
'gcc-gnat', 'libgnat', 'zlib-devel',
'gettext', 'libgcc', 'libgomp'])
for package in packages:
if not smm.check_installed(package) and not smm.install(package):
self.cancel(
"Failed to install %s required for this test." % package)
tarball = self.fetch_asset('gcc.zip', locations=[
'https://github.com/gcc-mirror/gcc/archive'
'/master.zip'], expire='7d')
archive.extract(tarball, self.workdir)
self.sourcedir = os.path.join(self.workdir, 'gcc-master')
os.chdir(self.sourcedir)
process.run('./configure', ignore_status=True, sudo=True)
build.make(self.sourcedir, ignore_status=True)
def setUp(self):
'''
set up required packages and gather necessary test inputs
'''
smm = SoftwareManager()
packages = [
'src', 'rsct.basic', 'rsct.core.utils', 'rsct.core', 'DynamicRM',
'powerpc-utils'
]
for pkg in packages:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel('%s is needed for the test to be run' % pkg)
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")
self.login(self.hmc_ip, self.hmc_username, self.hmc_pwd)
cmd = 'lssyscfg -r sys -F name'
output = self.run_command(cmd)
self.server = ''
for line in output.splitlines():
if line in self.lpar:
self.server = line
break
if not self.server:
self.cancel("Managed System not got")
self.sriov_adapter = self.params.get('sriov_adapter',
'*',
default=None).split(' ')
self.sriov_port = self.params.get('sriov_port', '*',
default=None).split(' ')
self.ipaddr = self.params.get('ipaddr', '*', default="").split(' ')
self.netmask = self.params.get('netmasks', '*', default="").split(' ')
self.peer_ip = self.params.get('peer_ip', '*', default="").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.local = LocalHost()
def setUp(self):
"""
Check existence of input PV,VG, LV and snapshots prior to Test.
"""
pkg = ""
smm = SoftwareManager()
self.disk = self.params.get('disk', default=None)
vg_name = self.params.get('vg_name', default='avocado_vg')
lv_name = self.params.get('lv_name', default='avocado_lv')
self.lv_size = self.params.get('lv_size', default='1G')
self.fs_name = self.params.get('fs', default='ext4').lower()
if self.fs_name == 'xfs':
pkg = 'xfsprogs'
if self.fs_name == 'btrfs':
if distro.detect().name == 'SuSE':
pkg = 'btrfsprogs'
else:
pkg = 'btrfs-progs'
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)
lv_snapshot_name = self.params.get('lv_snapshot_name',
default='avocado_sn')
self.lv_snapshot_size = self.params.get('lv_snapshot_size',
default='1G')
self.ramdisk_vg_size = self.params.get('ramdisk_vg_size',
default='10000')
self.ramdisk_basedir = self.params.get('ramdisk_basedir',
default=self.workdir)
self.ramdisk_sparse_filename = self.params.get(
'ramdisk_sparse_filename', default='virtual_hdd')
if lv_utils.vg_check(vg_name):
self.cancel('Volume group %s already exists' % vg_name)
self.vg_name = vg_name
if lv_utils.lv_check(vg_name, lv_name):
self.cancel('Logical Volume %s already exists' % lv_name)
self.lv_name = lv_name
if lv_utils.lv_check(vg_name, lv_snapshot_name):
self.cancel('Snapshot %s already exists' % lv_snapshot_name)
self.mount_loc = self.srcdir
self.lv_snapshot_name = lv_snapshot_name
def setUp(self):
smg = SoftwareManager()
dist = distro.detect()
self.args = self.params.get('args', default='')
self.mem_leak = self.params.get('mem_leak', default=0)
deps = ['gcc', 'make', 'automake', 'autoconf', 'psmisc']
if dist.name == "Ubuntu":
deps.extend(['libnuma-dev'])
elif dist.name in ["centos", "rhel", "fedora"]:
deps.extend(['numactl-devel'])
elif dist.name == "SuSE":
deps.extend(['libnuma-devel'])
self.ltpbin_dir = self.mount_dir = None
self.thp = False
if self.args in self.mem_tests:
self.mount_dir = self.params.get('tmpfs_mount_dir', default=None)
if self.mount_dir:
self.setup_tmpfs_dir()
over_commit = self.params.get('overcommit', default=True)
if not over_commit:
process.run('echo 2 > /proc/sys/vm/overcommit_memory',
shell=True,
ignore_status=True)
for package in deps:
if not smg.check_installed(package) and not smg.install(package):
self.cancel('%s is needed for the test to be run' % package)
clear_dmesg()
url = "https://github.com/linux-test-project/ltp/archive/master.zip"
tarball = self.fetch_asset("ltp-master.zip", locations=[url])
archive.extract(tarball, self.workdir)
ltp_dir = os.path.join(self.workdir, "ltp-master")
os.chdir(ltp_dir)
build.make(ltp_dir, extra_args='autotools')
if not self.ltpbin_dir:
self.ltpbin_dir = os.path.join(self.teststmpdir, 'bin')
if not os.path.exists(self.ltpbin_dir):
os.mkdir(self.ltpbin_dir)
process.system('./configure --prefix=%s' % self.ltpbin_dir)
build.make(ltp_dir)
build.make(ltp_dir, extra_args='install')
def setUp(self):
"""
Build 'fio'.
"""
print("start set up")
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.dirs = self.params.get('dir', default=self.workdir)
fstype = self.params.get('fs', default='ext4')
tarball = self.fetch_asset(url)
archive.extract(tarball, self.teststmpdir)
self.sourcedir = os.path.join(self.teststmpdir, "fio")
build.make(self.sourcedir)
print("set up done.")
smm = SoftwareManager()
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')
else:
pkg_list = ['libaio', 'libaio-devel']
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)
if self.disk is not None:
self.part_obj = Partition(self.disk, mountpoint=self.dirs)
self.fio_file = 'fiotest-image'
def setUp(self):
"""
Setting up the env for the kernel building
"""
smg = SoftwareManager()
self.detected_distro = distro.detect()
deps = ['gcc', 'make', 'automake', 'autoconf', 'time', 'bison', 'flex']
if 'Ubuntu' in self.detected_distro.name:
deps.extend([
'libpopt0', 'libc6', 'libc6-dev', 'libpopt-dev', 'libcap-ng0',
'libcap-ng-dev', 'elfutils', 'libelf1', 'libnuma-dev',
'libfuse-dev', 'libssl-dev'
])
elif 'SuSE' in self.detected_distro.name:
deps.extend([
'libpopt0', 'glibc', 'glibc-devel', 'popt-devel', 'libcap2',
'libcap-devel', 'libcap-ng-devel', 'openssl-devel'
])
elif self.detected_distro.name in ['centos', 'fedora', 'rhel']:
deps.extend([
'popt', 'glibc', 'glibc-devel', 'libcap-ng', 'libcap',
'libcap-devel', 'elfutils-libelf', 'elfutils-libelf-devel',
'openssl-devel'
])
for package in deps:
if not smg.check_installed(package) and not smg.install(package):
self.cancel('%s is needed for the test to be run' % package)
self.kernel_version = platform.uname()[2]
self.iterations = self.params.get('runs', default=1)
self.threads = self.params.get('cpus',
default=2 * cpu.online_cpus_count())
self.location = self.params.get(
'url',
default='https://github.com/torvalds/linux/archive'
'/master.zip')
self.config_path = os.path.join('/boot/config-', self.kernel_version)
# Uncompress the kernel archive to the work directory
tarball = self.fetch_asset("kernbench.zip",
locations=[self.location],
expire='1d')
archive.extract(tarball, self.workdir)
def setUp(self):
sm = SoftwareManager()
# Check for basic utilities
for package in ['gcc', 'make']:
if not sm.check_installed(package) and not sm.install(package):
self.error(package + ' is needed for the test to be run')
url = 'https://download.pureftpd.org/blogbench/blogbench-1.1.tar.bz2'
blogbench_url = self.params.get('blogbench_url', default=url)
blogbench_tarball = self.fetch_asset(blogbench_url, expire='7d')
archive.extract(blogbench_tarball, self.srcdir)
blogbench_version = os.path.basename(
blogbench_tarball.split('.tar.')[0])
self.blogbench_dir = os.path.join(self.srcdir, blogbench_version)
os.chdir(self.blogbench_dir)
patch = self.params.get('patch', default='config_guess.patch')
process.run('patch -p1 config.guess %s' %
os.path.join(self.datadir, patch),
shell=True)
process.system('./configure')
build.make(self.blogbench_dir, extra_args='install-strip')
def setUp(self):
'''
Install the basic packages to support evmctl
'''
# Check for basic utilities
smm = SoftwareManager()
deps = ['gcc', 'make']
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)
url = "https://sourceforge.net/projects/linux-ima/files/latest/download"
tarball = self.fetch_asset(name="download.tar.gz",
locations=url,
expire='7d')
archive.extract(tarball, self.workdir)
self.sourcedir = os.path.join(self.workdir,
os.listdir(self.workdir)[0])
self.log.info("sourcedir - %s" % self.sourcedir)
os.chdir(self.sourcedir)
process.run('./autogen.sh', ignore_status=True)
def setUp(self):
"""
Checking if the required packages are installed,
if not found packages will be installed
"""
smm = SoftwareManager()
if not smm.check_installed("smartctl"):
self.log.info("smartctl should be installed prior to the test")
if smm.install("smartmontools") is False:
self.cancel("Unable to install smartctl")
self.option = self.params.get('option')
self.disks = self.params.get('disk')
if self.disks is '' or self.option is '':
self.cancel(" Test skipped!!, please ensure Block device and \
options are specified in yaml file")
cmd = "df -h /boot | grep %s" % (self.disks)
if process.system(cmd, timeout=300, ignore_status=True,
shell=True) == 0:
self.cancel(" Skipping it's OS disk")
def setUp(self):
"""
Build 'nvme-cli' and setup the device.
"""
self.device = self.params.get('device', default='/dev/nvme0')
cmd = 'ls %s' % self.device
if process.system(cmd, ignore_status=True) is not 0:
self.skip("%s does not exist" % self.device)
smm = SoftwareManager()
if not smm.check_installed("nvme-cli") and not \
smm.install("nvme-cli"):
self.skip('nvme-cli is needed for the test to be run')
self.id_ns = self.create_namespace()
self.log.info(self.id_ns)
cmd = "nvme id-ns %s | grep 'in use' | awk '{print $5}' | \
awk -F':' '{print $NF}'" % self.id_ns
self.format_size = process.system_output(cmd, shell=True).strip('\n')
self.format_size = pow(2, int(self.format_size))
cmd = "nvme id-ns %s | grep 'in use' | awk '{print $2}'" % self.id_ns
self.lba = process.system_output(cmd, shell=True).strip('\n')
def setUp(self):
"""
Setting up the env for SDT markers
"""
smg = SoftwareManager()
detected_distro = distro.detect()
if 'ppc' not in distro.detect().arch:
self.cancel("Test supportd only on ppc64 arch")
deps = ['gcc', 'make']
if 'Ubuntu' in detected_distro.name:
deps.extend(['libc-dev', 'libc-bin', 'linux-tools-common',
'linux-tools-%s' % platform.uname()[2]])
elif detected_distro.name in ['rhel', 'SuSE', 'fedora', 'centos']:
deps.extend(['perf', 'glibc', 'glibc-devel'])
else:
self.cancel("Install the package for perf supported by %s"
% detected_distro.name)
for package in deps:
if not smg.check_installed(package) and not smg.install(package):
self.cancel('%s is needed for the test to be run' % package)
def setUp(self):
"""
Build tiobench.
Source:
https://github.com/mkuoppal/tiobench.git
"""
self.fstype = self.params.get('fs', default='ext4')
smm = SoftwareManager()
packages = ['gcc']
if self.fstype == 'btrfs':
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.srcdir)
os.chdir(os.path.join(self.srcdir, "tiobench-master"))
build.make(".")
def setUp(self):
'''
Install the packages
'''
# Check for basic utilities
smm = SoftwareManager()
detected_distro = distro.detect()
kernel_ver = platform.uname()[2]
deps = ['gcc', 'make']
if 'Ubuntu' in detected_distro.name:
deps.extend(['linux-tools-common', 'linux-tools-%s'
% kernel_ver])
elif detected_distro.name in ['redhat', 'SuSE', 'fedora']:
deps.extend(['perf'])
else:
self.skip("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.skip('%s is needed for the test to be run' % package)
