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):
        '''
        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):
        """
        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)
    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 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 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 '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):
     '''
     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 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))
Beispiel #10
0
    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.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):
        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)
Beispiel #13
0
    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 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 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):
     """
     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 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')
Beispiel #18
0
    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)
Beispiel #19
0
    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 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):
        '''
        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')
Beispiel #22
0
    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 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):

        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 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):

        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()
        for package in ['gcc', 'make', 'patch']:
            if not smm.check_installed(package) and not smm.install(package):
                self.cancel("%s is needed 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)
        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 'fio'.
        """
        default_url = "http://brick.kernel.dk/snaps/fio-2.1.10.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=self.srcdir)
        fstype = self.params.get('fs', default='ext4')
        tarball = self.fetch_asset(url)
        archive.extract(tarball, self.teststmpdir)
        fio_version = os.path.basename(tarball.split('.tar.')[0])
        self.sourcedir = os.path.join(self.teststmpdir, fio_version)
        build.make(self.sourcedir)

        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')

        if self.disk is not None:
            self.part_obj = Partition(self.disk, mountpoint=self.dir)
            self.log.info("Unmounting disk/dir before creating file system")
            self.part_obj.unmount()
            self.log.info("creating file system")
            self.part_obj.mkfs(fstype)
            self.log.info("Mounting disk %s on directory %s",
                          self.disk, self.dir)
            self.part_obj.mount()
    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):
        '''
        Build VA Test
        '''

        # Check for basic utilities
        smm = SoftwareManager()
        self.scenario_arg = int(self.params.get('scenario_arg', default=1))
        dic = {2: 1024, 3: 1024, 4: 131072, 5: 1, 6: 1, 7: 2}
        if self.scenario_arg not in range(1, 7):
            self.cancel("Test need to skip as scenario will be 1-7")
        if self.scenario_arg in [2, 3, 4]:
            if memory.meminfo.Hugepagesize.mb != 16:
                self.cancel(
                    "Test need to skip as 16MB huge need to configured")
        elif self.scenario_arg in [5, 6, 7]:
            if memory.meminfo.Hugepagesize.gb != 16:
                self.cancel(
                    "Test need to skip as 16GB huge need to configured")
        if self.scenario_arg != 1:
            memory.set_num_huge_pages(dic[self.scenario_arg])

        for packages in ['gcc', 'make']:
            if not smm.check_installed(packages) and not smm.install(packages):
                self.cancle('%s is needed for the test to be run' % packages)

        shutil.copyfile(os.path.join(self.datadir, 'va_test.c'),
                        os.path.join(self.teststmpdir, 'va_test.c'))

        shutil.copyfile(os.path.join(self.datadir, 'Makefile'),
                        os.path.join(self.teststmpdir, 'Makefile'))

        build.make(self.teststmpdir)
    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)
Beispiel #31
0
    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.channel_no = self.params.get('channel_no')
        self.disk_no = self.params.get('disk_no', default="").split(",")
        self.pci_id = self.params.get('pci_id', default="").split(",")
        self.logicaldrive = self.params.get('logicaldrive')
        self.diskoverwrite = self.params.get('diskoverwrite')
        self.fs_type = self.params.get('fs_type')
        self.mount_point = self.params.get('mount_point')
        self.http_path = self.params.get('http_path')
        self.tool_name = self.params.get('tool_name')

        # Gets the list of PCIIDs on the system
        cmd = r'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 = self.cmdop_list(cmd)
        pci_id_formatted = []
        for i in pci_id.splitlines():
            pci_id_formatted.append(str(i.replace(" ", ":")))

        # check if all the yaml parameters are entered
        if self.crtl_no is '' or self.channel_no is '' or self.disk_no is \
           '' or self.pci_id is '' or len(self.disk_no) <= 1 or \
           self.fs_type is '' or self.mount_point is '' or self.tool_name \
           is '' or self.http_path is '':
            self.cancel(" Test skipped!!, please ensure yaml parameters are \
            entered or disk count is more than 1")
        elif self.comp(self.pci_id, pci_id_formatted) == 1:
            self.cancel(" Test skipped!!, PMC controller not available")

        detected_distro = distro.detect()
        if not smm.check_installed("Arcconf"):
            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.run(cmd, shell=True) == 0:
                self.cancel("Unable to install arcconf")

        cmd = "lsscsi  | grep LogicalDrv | awk \'{print $7}\'"
        self.os_drive = self.cmdop_list(cmd)

        if self.diskoverwrite == 'Y' and self.os_drive != "":
            # Delete a logical drive only if it is not OS drive
            cmd = "df -h /boot | grep %s" % self.os_drive
            if process.system(cmd, timeout=300, ignore_status=True,
                              shell=True) == 0:
                self.cancel("Test Skipped!! OS disk requested for removal")

            self.log.info("Deleting the default logical drive %s" %
                          (self.logicaldrive))
            cmd = "echo y | arcconf delete %s logicaldrive %s" % \
                (self.crtl_no, self.logicaldrive)
            self.check_pass(cmd, "Failed to delete Logical drive")
    def setUp(self):
        '''
        To check and install dependencies for the test
        '''
        detected_distro = distro.detect()
        smm = SoftwareManager()
        depends = []
        # 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 detected_distro.name == "Ubuntu":
            depends.extend(["openssh-client", "iputils-ping"])
        elif detected_distro.name in ["rhel", "fedora", "centos", "redhat"]:
            depends.extend(["openssh-clients", "iputils"])
        else:
            depends.extend(["openssh", "iputils"])
        for pkg in depends:
            if not smm.check_installed(pkg) and not smm.install(pkg):
                self.cancel("%s package is need to test" % pkg)
        self.mode = self.params.get("bonding_mode", default="")
        if 'setup' in str(self.name) or 'run' in str(self.name):
            if not self.mode:
                self.cancel("test skipped because mode not specified")
        interfaces = netifaces.interfaces()
        self.peer_public_ip = self.params.get("peer_public_ip", default="")
        self.user = self.params.get("user_name", default="root")
        self.password = self.params.get("peer_password", '*', default="None")
        self.host_interfaces = self.params.get("bond_interfaces",
                                               default="").split(" ")
        if not self.host_interfaces:
            self.cancel("user should specify host interfaces")
        self.peer_interfaces = self.params.get("peer_interfaces",
                                               default="").split(" ")
        for self.host_interface in self.host_interfaces:
            if self.host_interface not in interfaces:
                self.cancel("interface is not available")
        self.peer_first_ipinterface = self.params.get("peer_ip", default="")
        if not self.peer_interfaces or self.peer_first_ipinterface == "":
            self.cancel("peer machine should available")
        self.ipaddr = self.params.get("host_ips", default="").split(" ")
        self.netmask = self.params.get("netmask", default="")
        self.localhost = LocalHost()
        if 'setup' in str(self.name.name):
            for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
                networkinterface = NetworkInterface(interface, self.localhost)
                try:
                    networkinterface.flush_ipaddr()
                    networkinterface.add_ipaddr(ipaddr, self.netmask)
                    networkinterface.save(ipaddr, self.netmask)
                except Exception:
                    networkinterface.save(ipaddr, self.netmask)
                networkinterface.bring_up()
        self.miimon = self.params.get("miimon", default="100")
        self.fail_over_mac = self.params.get("fail_over_mac", default="2")
        self.downdelay = self.params.get("downdelay", default="0")
        self.bond_name = self.params.get("bond_name", default="tempbond")
        self.net_path = "/sys/class/net/"
        self.bond_status = "/proc/net/bonding/%s" % self.bond_name
        self.bond_dir = os.path.join(self.net_path, self.bond_name)
        self.bonding_slave_file = "%s/bonding/slaves" % self.bond_dir
        self.bonding_masters_file = "%s/bonding_masters" % self.net_path
        self.peer_bond_needed = self.params.get("peer_bond_needed",
                                                default=False)
        self.peer_wait_time = self.params.get("peer_wait_time", default=20)
        self.sleep_time = int(self.params.get("sleep_time", default=10))
        self.mtu = self.params.get("mtu", default=1500)
        for root, dirct, files in os.walk("/root/.ssh"):
            for file in files:
                if file.startswith("avocado-master-"):
                    path = os.path.join(root, file)
                    os.remove(path)
        self.ib = False
        if self.host_interface[0:2] == 'ib':
            self.ib = True
        self.log.info("Bond Test on IB Interface? = %s", self.ib)
        '''
        An individual interface, that has a LACP PF, cannot communicate without
        being bonded. So the test uses the public ip address to create an SSH
        session instead of the private one when setting up a bonding interface.
        '''
        if self.mode == "4" and "setup" in str(self.name.name):
            self.session = Session(self.peer_public_ip,
                                   user=self.user,
                                   password=self.password)
        else:
            self.session = Session(self.peer_first_ipinterface,
                                   user=self.user,
                                   password=self.password)

        if not self.session.connect():
            '''
            LACP bond interface takes some time to get it to ping peer after it
            is setup. This code block tries at most 5 times to get it to connect
            to the peer.
            '''
            if self.mode == "4":
                connect = False
                for _ in range(5):
                    if self.session.connect():
                        connect = True
                        self.log.info("Was able to connect to peer.")
                        break
                    time.sleep(5)
                if not connect:
                    self.cancel("failed connecting to peer")
            else:
                self.cancel("failed connecting to peer")
        self.setup_ip()
        self.err = []
        if self.mode == "4" and "setup" in str(self.name.name):
            self.remotehost = RemoteHost(self.peer_public_ip,
                                         self.user,
                                         password=self.password)
        else:
            self.remotehost = RemoteHost(self.peer_first_ipinterface,
                                         self.user,
                                         password=self.password)

        if 'setup' in str(self.name.name):
            for interface in self.peer_interfaces:
                peer_networkinterface = NetworkInterface(
                    interface, self.remotehost)
                if peer_networkinterface.set_mtu(self.mtu) is not None:
                    self.cancel("Failed to set mtu in peer")
            for host_interface in self.host_interfaces:
                self.networkinterface = NetworkInterface(
                    host_interface, self.localhost)
                if self.networkinterface.set_mtu(self.mtu) is not None:
                    self.cancel("Failed to set mtu in host")
Beispiel #33
0
    def test(self):
        detected_distro = distro.detect()
        parser = configparser.ConfigParser()
        parser.read(self.get_data('services.cfg'))
        services_list = parser.get(detected_distro.name, 'services').split(',')

        smm = SoftwareManager()
        deps = []

        if detected_distro.name == 'SuSE':
            deps.extend(['ppc64-diag', 'libvirt-daemon'])
            if detected_distro.version >= 15:
                services_list.append('firewalld')
            else:
                services_list.append('SuSEfirewall2')
        elif detected_distro.name == 'Ubuntu':
            deps.extend(['opal-prd'])
            if detected_distro.version >= 17:
                services_list.remove('networking')

        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)

        if 'PowerNV' in open('/proc/cpuinfo', 'r').read():
            services_list.extend(['opal_errd', 'opal-prd'])
            if os.path.exists('/proc/device-tree/bmc'):
                services_list.remove('opal_errd')
        else:
            services_list.extend(['rtas_errd'])
        services_failed = []
        runner = process.run

        for service in services_list:
            service_obj = SpecificServiceManager(service, runner)
            self.log.info("Checking %s service" % service)
            if service_obj.is_enabled() is False:
                self.log.info("%s service Not Found !!!" % service)
                services_failed.append(service)
                continue
            original_status = service_obj.status()
            if original_status is True:
                service_obj.stop()
                if not wait_for(lambda: not service_obj.status(), 10):
                    self.log.info("Fail to stop %s service" % service)
                    services_failed.append(service)
                    continue
                service_obj.start()
                wait_for(service_obj.status, 10)
            else:
                service_obj.start()
                if not wait_for(service_obj.status, 10):
                    self.log.info("Fail to start %s service" % service)
                    services_failed.append(service)
                    continue
                service_obj.stop()
                wait_for(lambda: not service_obj.status(), 10)
            if not service_obj.status() is original_status:
                self.log.info("Fail to restore original status of the %s"
                              "service" % service)
                services_failed.append(service)

        if services_failed:
            self.fail("List of services failed: %s" % services_failed)
        else:
            self.log.info("All Services Passed the ON/OFF test")
    def build_htx(self):
        """
        Build 'HTX'
        """
        packages = ['git', 'gcc', 'make']
        detected_distro = distro.detect()
        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', 'tar'])
        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)
            cmd = "ssh %s@%s \"%s install %s\"" % (
                self.peer_user, self.peer_ip, smm.backend.base_command, pkg)
            if process.system(cmd, shell=True, ignore_status=True) != 0:
                self.cancel(
                    "unable to install the package %s on peer machine " % pkg)
        if self.htx_url:
            htx = self.htx_url.split("/")[-1]
            htx_rpm = self.fetch_asset(self.htx_url)
            process.system("rpm -ivh --force %s" % htx_rpm)
            self.run_command("wget %s -O /tmp/%s" % (self.htx_url, htx))
            self.run_command("cd /tmp")
            self.run_command("rpm -ivh --force %s" % htx)
        else:
            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", "hxecapi", "hxeocapi"]
            if not smm.check_installed('dapl-devel'):
                exercisers.append("hxedapl")
            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")

            try:
                self.run_command("wget %s -O /tmp/master.zip" % url)
                self.run_command("cd /tmp")
                self.run_command("unzip master.zip")
                self.run_command("cd HTX-master")
                for exerciser in exercisers:
                    self.run_command("sed -i 's/%s//g' bin/Makefile" %
                                     exerciser)
                self.run_command("make all")
                self.run_command("make tar")
                self.run_command("tar --touch -xvzf htx_package.tar.gz")
                self.run_command("cd htx_package")
                self.run_command("./installer.sh -f")
            except CommandFailed:
                self.cancel("HTX is not installed on Peer")
Beispiel #35
0
    def setUp(self):
        """
        Build xfstest
        Source: git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git
        """
        self.use_dd = False
        root_fs = process.system_output(
            "df -T / | awk 'END {print $2}'", shell=True).decode("utf-8")
        if root_fs in ['ext3', 'ext4']:
            self.use_dd = True
        sm = SoftwareManager()

        self.detected_distro = distro.detect()

        packages = ['e2fsprogs', 'automake', 'gcc', 'quota', 'attr',
                    'make', 'xfsprogs', 'gawk']
        if 'Ubuntu' in self.detected_distro.name:
            packages.extend(
                ['xfslibs-dev', 'uuid-dev', 'libuuid1',
                 'libattr1-dev', 'libacl1-dev', 'libgdbm-dev',
                 'uuid-runtime', 'libaio-dev', 'fio', 'dbench', 'btrfs-tools'])
            if '14' in self.detected_distro.version:
                packages.extend(['libtool'])
            elif '18' in self.detected_distro.version:
                packages.extend(['libtool-bin', 'libgdbm-compat-dev'])
            else:
                packages.extend(['libtool-bin'])

        # 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 self.detected_distro.name in ['centos', 'fedora', 'rhel', 'SuSE']:
            packages.extend(['acl', 'bc', 'dump', 'indent', 'libtool', 'lvm2',
                             'xfsdump', 'psmisc', 'sed', 'libacl-devel',
                             'libattr-devel', 'libaio-devel', 'libuuid-devel',
                             'openssl-devel', 'xfsprogs-devel'])

            if self.detected_distro.name == 'SuSE':
                packages.extend(['libbtrfs-devel', 'libcap-progs'])
            else:
                packages.extend(['btrfs-progs-devel'])

            if self.detected_distro.name == 'rhel' and\
                    self.detected_distro.version.startswith('8'):
                packages.remove('indent')
                packages.remove('btrfs-progs-devel')

            if self.detected_distro.name in ['centos', 'fedora']:
                packages.extend(['fio', 'dbench'])
        else:
            self.cancel("test not supported in %s" % self.detected_distro.name)

        for package in packages:
            if not sm.check_installed(package) and not sm.install(package):
                self.cancel("Fail to install %s required for this test." %
                            package)

        self.skip_dangerous = self.params.get('skip_dangerous', default=True)
        self.test_range = self.params.get('test_range', default=None)
        self.scratch_mnt = self.params.get(
            'scratch_mnt', default='/mnt/scratch')
        self.test_mnt = self.params.get('test_mnt', default='/mnt/test')
        self.disk_mnt = self.params.get('disk_mnt', default='/mnt/loop_device')
        self.dev_type = self.params.get('type', default='loop')
        self.fs_to_test = self.params.get('fs', default='ext4')
        if process.system('which mkfs.%s' % self.fs_to_test,
                          ignore_status=True):
            self.cancel('Unknown filesystem %s' % self.fs_to_test)
        mount = True
        self.devices = []
        self.log_devices = []
        shutil.copyfile(self.get_data('local.config'),
                        os.path.join(self.teststmpdir, 'local.config'))
        shutil.copyfile(self.get_data('group'),
                        os.path.join(self.teststmpdir, 'group'))

        if self.dev_type == 'loop':
            base_disk = self.params.get('disk', default=None)
            loop_size = self.params.get('loop_size', default='7GiB')
            if not base_disk:
                # Using root for file creation by default
                check = (int(loop_size.split('GiB')[0]) * 2) + 1
                if disk.freespace('/') / 1073741824 > check:
                    self.disk_mnt = ''
                    mount = False
                else:
                    self.cancel('Need %s GB to create loop devices' % check)
            self._create_loop_device(base_disk, loop_size, mount)
        else:
            self.test_dev = self.params.get('disk_test', default=None)
            self.scratch_dev = self.params.get('disk_scratch', default=None)
            self.devices.extend([self.test_dev, self.scratch_dev])
        # mkfs for devices
        if self.devices:
            cfg_file = os.path.join(self.teststmpdir, 'local.config')
            self.mkfs_opt = self.params.get('mkfs_opt', default='')
            self.mount_opt = self.params.get('mount_opt', default='')
            self.log_test = self.params.get('log_test', default='')
            self.log_scratch = self.params.get('log_scratch', default='')
            with open(cfg_file, "r") as sources:
                lines = sources.readlines()
            with open(cfg_file, "w") as sources:
                for line in lines:
                    if line.startswith('export TEST_DEV'):
                        sources.write(
                            re.sub(r'export TEST_DEV=.*', 'export TEST_DEV=%s'
                                   % self.devices[0], line))
                    elif line.startswith('export TEST_DIR'):
                        sources.write(
                            re.sub(r'export TEST_DIR=.*', 'export TEST_DIR=%s'
                                   % self.test_mnt, line))
                    elif line.startswith('export SCRATCH_DEV'):
                        sources.write(re.sub(
                            r'export SCRATCH_DEV=.*', 'export SCRATCH_DEV=%s'
                                                      % self.devices[1], line))
                    elif line.startswith('export SCRATCH_MNT'):
                        sources.write(
                            re.sub(
                                r'export SCRATCH_MNT=.*',
                                'export SCRATCH_MNT=%s' %
                                self.scratch_mnt,
                                line))
                        break
            with open(cfg_file, "a") as sources:
                if self.log_test:
                    sources.write('export TEST_LOGDEV="%s"\n' % self.log_test)
                    self.log_devices.append(self.log_test)
                if self.log_scratch:
                    sources.write('export SCRATCH_LOGDEV="%s"\n' % self.log_scratch)
                    self.log_devices.append(self.log_scratch)
                if self.mkfs_opt:
                    sources.write('MKFS_OPTIONS="%s"\n' % self.mkfs_opt)
                if self.mount_opt:
                    sources.write('MOUNT_OPTIONS="%s"\n' % self.mount_opt)
            self.logdev_opt = self.params.get('logdev_opt', default='')
            for dev in self.log_devices:
                dev_obj = partition.Partition(dev)
                dev_obj.mkfs(fstype=self.fs_to_test, args=self.mkfs_opt)
            for ite, dev in enumerate(self.devices):
                dev_obj = partition.Partition(dev)
                if self.logdev_opt:
                    dev_obj.mkfs(fstype=self.fs_to_test, args='%s %s=%s' % (self.mkfs_opt, self.logdev_opt, self.log_devices[ite]))
                else:
                    dev_obj.mkfs(fstype=self.fs_to_test, args=self.mkfs_opt)

        git.get_repo('git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git',
                     destination_dir=self.teststmpdir)

        build.make(self.teststmpdir)
        self.available_tests = self._get_available_tests()

        self.test_list = self._create_test_list(self.test_range)
        self.log.info("Tests available in srcdir: %s",
                      ", ".join(self.available_tests))
        if not self.test_range:
            self.exclude = self.params.get('exclude', default=None)
            self.gen_exclude = self.params.get('gen_exclude', default=None)
            self.share_exclude = self.params.get('share_exclude', default=None)
            if self.exclude or self.gen_exclude or self.share_exclude:
                self.exclude_file = os.path.join(self.teststmpdir, 'exclude')
                if self.exclude:
                    self._create_test_list(self.exclude, self.fs_to_test,
                                           dangerous=False)
                if self.gen_exclude:
                    self._create_test_list(self.gen_exclude, "generic",
                                           dangerous=False)
                if self.share_exclude:
                    self._create_test_list(self.share_exclude, "shared",
                                           dangerous=False)
        if self.detected_distro.name is not 'SuSE':
            process.run('useradd 123456-fsgqa', sudo=True)
            process.run('useradd fsgqa', sudo=True)
        else:
            process.run('useradd -m -U fsgqa', sudo=True)
            process.run('groupadd sys', sudo=True)
        if not os.path.exists(self.scratch_mnt):
            os.makedirs(self.scratch_mnt)
        if not os.path.exists(self.test_mnt):
            os.makedirs(self.test_mnt)
Beispiel #36
0
    def setUp(self):
        """
        Set up.
        """
        self.iface = self.params.get("interface", default="")
        self.count = self.params.get("count", default="500")
        self.nping_count = self.params.get("nping_count", default="")
        self.peer_ip = self.params.get("peer_ip", default="")
        self.peer_public_ip = self.params.get("peer_public_ip", default="")
        self.drop = self.params.get("drop_accepted", default="10")
        self.host_ip = self.params.get("host_ip", default="")
        self.option = self.params.get("option", default='')
        # Check if interface exists in the system
        interfaces = netifaces.interfaces()
        if self.iface not in interfaces:
            self.cancel("%s interface is not available" % self.iface)
        if not self.peer_ip:
            self.cancel("peer ip should specify in input")
        self.ipaddr = self.params.get("host_ip", default="")
        self.netmask = self.params.get("netmask", default="")
        localhost = LocalHost()
        self.networkinterface = NetworkInterface(self.iface, localhost)
        try:
            self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
            self.networkinterface.save(self.ipaddr, self.netmask)
        except Exception:
            self.networkinterface.save(self.ipaddr, self.netmask)
        self.networkinterface.bring_up()
        if not wait.wait_for(self.networkinterface.is_link_up, timeout=120):
            self.cancel(
                "Link up of interface is taking longer than 120 seconds")
        self.peer_user = self.params.get("peer_user", default="root")
        self.peer_password = self.params.get("peer_password",
                                             '*',
                                             default="None")
        self.mtu = self.params.get("mtu", default=1500)
        self.remotehost = RemoteHost(self.peer_ip,
                                     self.peer_user,
                                     password=self.peer_password)
        self.peer_interface = self.remotehost.get_interface_by_ipaddr(
            self.peer_ip).name
        self.peer_networkinterface = NetworkInterface(self.peer_interface,
                                                      self.remotehost)
        self.remotehost_public = RemoteHost(self.peer_public_ip,
                                            self.peer_user,
                                            password=self.peer_password)
        self.peer_public_networkinterface = NetworkInterface(
            self.peer_interface, self.remotehost_public)
        if self.peer_networkinterface.set_mtu(self.mtu) is not None:
            self.cancel("Failed to set mtu in peer")
        if self.networkinterface.set_mtu(self.mtu) is not None:
            self.cancel("Failed to set mtu in host")

        # Install needed packages
        smm = SoftwareManager()
        detected_distro = distro.detect()
        pkgs = ['tcpdump', 'flex', 'bison', 'gcc', 'gcc-c++', 'nmap']
        for pkg in pkgs:
            if not smm.check_installed(pkg) and not smm.install(pkg):
                self.cancel("%s package Can not install" % pkg)
        if detected_distro.name == "SuSE":
            self.nmap = os.path.join(self.teststmpdir, 'nmap')
            nmap_download = self.params.get("nmap_download",
                                            default="https:"
                                            "//nmap.org/dist/"
                                            "nmap-7.80.tar.bz2")
            tarball = self.fetch_asset(nmap_download)
            self.version = os.path.basename(tarball.split('.tar')[0])
            self.n_map = os.path.join(self.nmap, self.version)
            archive.extract(tarball, self.nmap)
            os.chdir(self.n_map)
            process.system('./configure ppc64le', shell=True)
            build.make(self.n_map)
            process.system('./nping/nping -h', shell=True)
Beispiel #37
0
class NdctlTest(Test):
    """
    Ndctl user space tooling for Linux, which handles NVDIMM devices.
    """
    def get_default_region(self):
        """
        Get the largest region if not provided
        """
        self.plib.enable_region()
        region = self.params.get('region', default=None)
        if region:
            return region
        regions = self.plib.run_ndctl_list('-R')
        regions = sorted(regions, key=lambda i: i['size'], reverse=True)
        return self.plib.run_ndctl_list_val(regions[0], 'dev')

    def get_unsupported_alignval(self):
        """
        Return unsupported size align based on platform
        """
        align = self.get_size_alignval()
        if align == self.align_val['hash']:
            return self.align_val['radix']
        else:
            return self.align_val['hash']

    def get_size_alignval(self):
        """
        Return the size align restriction based on platform
        """
        self.align_val = {'hash': 16777216, 'radix': 2097152}
        if 'Hash' in genio.read_file('/proc/cpuinfo').rstrip('\t\r\n\0'):
            def_align = self.align_val['hash']
        else:
            def_align = self.align_val['radix']
        return def_align

    def build_fio(self):
        """
        Install fio or build if not possible
        """
        pkg = "fio"
        if process.system("which %s" % pkg, ignore_status=True):
            if not self.smm.check_installed(pkg) \
                    and not self.smm.install(pkg):
                for package in ["autoconf", "libtool", "make"]:
                    if not self.smm.check_installed(package) \
                            and not self.smm.install(package):
                        self.cancel(
                            "Fail to install %s required for this test."
                            "" % package)
                tarball = self.fetch_asset(
                    "http://brick.kernel.dk/snaps/fio-2.1.10.tar.gz")
                archive.extract(tarball, self.teststmpdir)
                fio_version = os.path.basename(tarball.split('.tar.')[0])
                sourcedir = os.path.join(self.teststmpdir, fio_version)
                build.make(sourcedir)
                return os.path.join(sourcedir, "fio")
        return pkg

    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', 'kmod-devel', 'libuuid-devel', 'json-c-devel',
                    'systemd-devel', 'keyutils-libs-devel', 'jq', 'parted',
                    'libtool'
                ])
            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")

    @avocado.fail_on(pmem.PMemException)
    def test_bus_ids(self):
        """
        Test the bus id info
        """
        vals = self.plib.run_ndctl_list('-B')
        if not vals:
            self.fail('Failed to fetch bus IDs')
        self.log.info('Available Bus provider IDs: %s', vals)

    @avocado.fail_on(pmem.PMemException)
    def test_dimms(self):
        """
        Test the dimms info
        """
        vals = self.plib.run_ndctl_list('-D')
        if not vals:
            self.fail('Failed to fetch DIMMs')
        self.log.info('Available DIMMs: %s', vals)

    @avocado.fail_on(pmem.PMemException)
    def test_dimm_health(self):
        """
        Test the dimm health
        """
        dimms = self.plib.run_ndctl_list('-DH')
        if not dimms:
            self.fail('Failed to fetch DIMMs')
        for dimm in dimms:
            health = self.plib.run_ndctl_list_val(dimm, 'health')
            if not health:
                self.cancel("kernel/ndctl does not support health reporting")
            if 'life_used_percentage' in health:
                if health['life_used_percentage'] != 0:
                    self.fail(
                        "DIMM has not been used, reporting says otherwise")
            if 'health_state' in health:
                if health['health_state'] != "ok":
                    self.fail("DIMM health is bad")
            if 'shutdown_state' in health:
                if health['shutdown_state'] != "clean":
                    self.fail("DIMM shutdown state is dirty")
            dim = self.plib.run_ndctl_list_val(dimm, 'dev')
            self.log.info("Dimm %s Health info: %s", dim, health)

    @avocado.fail_on(pmem.PMemException)
    def test_regions(self):
        """
        Test the regions info
        """
        self.plib.disable_region()
        old = self.plib.run_ndctl_list('-R')
        self.plib.enable_region()
        new = self.plib.run_ndctl_list('-R')
        if len(new) <= len(old):
            self.fail('Failed to fetch regions')
        self.log.info('Available regions: %s', new)

    @avocado.fail_on(pmem.PMemException)
    def test_namespace(self):
        """
        Test namespace
        """
        self.plib.enable_region()
        regions = self.plib.run_ndctl_list('-R')
        for val in regions:
            region = self.plib.run_ndctl_list_val(val, 'dev')
            self.plib.disable_namespace(region=region)
            self.plib.destroy_namespace(region=region)
            self.plib.create_namespace(region=region)

        namespaces = self.plib.run_ndctl_list('-N')
        self.log.info('Created namespace %s', namespaces)

    @avocado.fail_on(pmem.PMemException)
    def test_namespace_unaligned(self):
        """
        Test namespace
        """
        self.plib.enable_region()
        # Use an default unaligned pagesize and make sure it fails
        align_size = memory.get_page_size()
        size = (64 * 1024 * 1024) + align_size
        regions = self.plib.run_ndctl_list('-R')
        for val in regions:
            region = self.plib.run_ndctl_list_val(val, 'dev')
            self.plib.disable_namespace(region=region)
            self.plib.destroy_namespace(region=region)
            try:
                self.plib.create_namespace(region=region,
                                           size=size,
                                           align=align_size)
            except pmem.PMemException:
                self.log.info("Unaligned namespace creation failed"
                              "as expected")
            else:
                self.fail("Unaligned namespace creation must have failed! ")

    @avocado.fail_on(pmem.PMemException)
    def test_disable_enable_ns(self):
        """
        Test enable disable namespace
        """
        region = self.get_default_region()
        if (not self.plib.is_region_legacy(region)):
            size = self.plib.run_ndctl_list_val(
                self.plib.run_ndctl_list('-r %s' % region)[0], 'size')
            if size < (3 * 64 * 1024 * 1024):
                self.cancel('Not enough memory to create namespaces')
            for _ in range(0, 3):
                self.plib.create_namespace(region=region, size='64M')
        namespaces = self.plib.run_ndctl_list('-N')
        ns_names = []
        for ns in namespaces:
            ns_names.append(self.plib.run_ndctl_list_val(ns, 'dev'))
        ns_names.append('all')

        for namespace in ns_names:
            self.plib.disable_namespace(namespace=namespace)
            self.plib.enable_namespace(namespace=namespace)

    @avocado.fail_on(pmem.PMemException)
    def test_namespace_modes(self):
        """
        Create  different namespace types
        """
        failed_modes = []
        region = self.get_default_region()
        self.log.info("Using %s for different namespace modes", region)
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        for mode in self.modes:
            self.plib.create_namespace(region=region, mode=mode)
            ns_json = self.plib.run_ndctl_list('-r %s -N' % region)[0]
            created_mode = self.plib.run_ndctl_list_val(ns_json, 'mode')
            if mode != created_mode:
                failed_modes.append(mode)
                self.log.error("Expected mode %s, Got %s", mode, created_mode)
            else:
                self.log.info("Namespace with %s mode: %s", mode, ns_json)
            ns_name = self.plib.run_ndctl_list_val(ns_json, 'dev')
            self.plib.disable_namespace(namespace=ns_name, region=region)
            self.plib.destroy_namespace(namespace=ns_name, region=region)

        if failed_modes:
            self.fail("Namespace for %s mode failed!" % failed_modes)

    @avocado.fail_on(pmem.PMemException)
    def test_namespace_devmap(self):
        """
        Test metadata device mapping option with a namespace
        """
        region = self.get_default_region()
        m_map = self.params.get('map', default='mem')
        self.log.info("Using %s for checking device mapping", region)
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region,
                                   mode=self.mode_to_use,
                                   memmap=m_map)
        self.log.info("Validating device mapping")
        map_val = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list('-r %s -N' % region)[0], 'map')
        if map_val != m_map:
            self.fail("Expected map:%s, Got %s" % (m_map, map_val))
        else:
            self.log.info("Metadata mapped as expected")

    def multiple_namespaces_region(self, region):
        """
        Test multiple namespace with single region
        """
        namespace_size = self.params.get('size', default=None)
        size_align = self.get_size_alignval()
        slot_count = self.plib.get_slot_count(region)
        self.log.info("Using %s for muliple namespace regions", region)
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        if namespace_size and ((namespace_size % size_align) != 0):
            self.cancel("Size value not %d aligned %d \n", size_align,
                        namespace_size)

        region_size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list('-r %s' % region)[0], 'size')
        if not namespace_size:
            namespace_size = region_size // slot_count
            # Now align the namespace size
            namespace_size = (namespace_size // size_align) * size_align
        else:
            slot_count = region_size // namespace_size

        if namespace_size <= size_align:
            self.log.warn("Ns size equal to pagesize, hence skipping region")
            return

        self.log.info("Creating %s namespaces", slot_count)
        for count in range(0, slot_count):
            self.plib.create_namespace(region=region,
                                       mode=self.mode_to_use,
                                       size=namespace_size)
            self.log.info("Namespace %s created", count + 1)

    @avocado.fail_on(pmem.PMemException)
    def test_multiple_namespaces_region(self):
        """
        Test multiple namespace with single region
        """
        region = self.get_default_region()
        if (self.plib.is_region_legacy(region)):
            self.cancel("Legacy config skipping the test")
        self.multiple_namespaces_region(region)

    @avocado.fail_on(pmem.PMemException)
    def test_multiple_ns_multiple_region(self):
        """
        Test multiple namespace with multiple region
        """
        self.plib.enable_region()
        if len(self.plib.run_ndctl_list('-R')) <= 1:
            self.cancel("Test not applicable without multiple regions")
        regions = self.plib.run_ndctl_list('-R')
        self.plib.disable_namespace()
        self.plib.destroy_namespace()
        for val in regions:
            region = self.plib.run_ndctl_list_val(val, 'dev')
            if (self.plib.is_region_legacy(region)):
                self.cancel("Legacy config skipping the test")
            self.multiple_namespaces_region(region)

    @avocado.fail_on(pmem.PMemException)
    def test_multiple_ns_modes_region(self):
        """
        Test multiple namespace modes with single region
        """
        region = self.get_default_region()
        if (self.plib.is_region_legacy(region)):
            self.cancel("Legacy config skipping the test")
        self.log.info("Using %s for muliple namespace regions", region)
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list('-r %s' % region)[0], 'size')
        if size < (len(self.modes) * 64 * 1024 * 1024):
            self.cancel('Not enough memory to create namespaces')
        for mode in self.modes:
            self.plib.create_namespace(region=region, mode=mode, size='64M')
            self.log.info("Namespace of type %s created", mode)

    @avocado.fail_on(pmem.PMemException)
    def test_nslot_namespace(self):
        """
        Test max namespace with nslot value
        """
        region = self.get_default_region()
        if (self.plib.is_region_legacy(region)):
            self.cancel("Legacy config skipping the test")
        size_align = self.get_size_alignval()
        slot_count = self.plib.get_slot_count(region)
        self.log.info("Using %s for max namespace creation", region)
        self.plib.disable_namespace()
        self.plib.destroy_namespace()
        region_size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list('-r %s' % region)[0], 'size')
        namespace_size = region_size // slot_count
        # Now align the namespace size
        namespace_size = (namespace_size // size_align) * size_align

        self.log.info("Creating %s namespace", slot_count)
        for count in range(0, slot_count):
            self.plib.create_namespace(region=region,
                                       mode='fsdax',
                                       size=namespace_size)
            self.log.info("Namespace %s created", count)

    @avocado.fail_on(pmem.PMemException)
    def test_namespace_reconfigure(self):
        """
        Test namespace reconfiguration
        """
        region = self.get_default_region()
        self.log.info("Using %s for reconfiguring namespace", region)
        self.plib.disable_namespace()
        self.plib.destroy_namespace()
        self.plib.create_namespace(region=region, mode='fsdax', align='64k')
        old_ns = self.plib.run_ndctl_list()[0]
        old_ns_dev = self.plib.run_ndctl_list_val(old_ns, 'dev')
        self.log.info("Re-configuring namespace %s", old_ns_dev)
        self.plib.create_namespace(region=region,
                                   mode='fsdax',
                                   name='test_ns',
                                   reconfig=old_ns_dev,
                                   force=True)
        new_ns = self.plib.run_ndctl_list()[0]
        self.log.info("Checking namespace changes")
        failed_vals = []
        for key, val in new_ns.items():
            if key in list(set(old_ns.keys()) - set(['uuid', 'dev'])):
                if old_ns[key] != val:
                    failed_vals.append({key: val})
            else:
                self.log.info("Newly added filed %s:%s", key, val)
        if failed_vals:
            self.fail("New namespace unexpected change(s): %s" % failed_vals)

    @avocado.fail_on(pmem.PMemException)
    def test_check_namespace(self):
        """
        Verify metadata for sector mode namespaces
        """
        region = self.get_default_region()
        self.plib.disable_namespace()
        self.plib.destroy_namespace()
        self.log.info("Creating sector namespace using %s", region)
        self.plib.create_namespace(region=region, mode='sector')
        ns_sec_dev = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list()[0], 'dev')
        self.plib.disable_namespace(namespace=ns_sec_dev)
        self.log.info("Checking BTT metadata")
        if process.system("%s check-namespace %s" % (self.ndctl, ns_sec_dev),
                          ignore_status=True):
            self.fail("Failed to check namespace metadata")

    @avocado.fail_on(pmem.PMemException)
    def test_check_numa(self):
        self.plib.enable_region()
        regions = self.plib.run_ndctl_list('-R')
        if not os.path.exists('/sys/bus/nd/devices/region0/numa_node'):
            self.fail("Numa node entries not found!")
        for val in regions:
            reg = self.plib.run_ndctl_list_val(val, 'dev')
            numa = genio.read_one_line('/sys/bus/nd/devices/%s/numa_node' %
                                       reg)
            # Check numa config in ndctl and sys interface
            if len(self.plib.run_ndctl_list('-r %s -R -U %s' %
                                            (reg, numa))) != 1:
                self.fail('Region mismatch between ndctl and sys interface')

    @avocado.fail_on(pmem.PMemException)
    def test_check_ns_numa(self):
        self.plib.enable_region()
        regions = self.plib.run_ndctl_list('-R')
        for dev in regions:
            region = self.plib.run_ndctl_list_val(dev, 'dev')
            if not self.plib.is_region_legacy(region):
                self.plib.disable_namespace(region=region)
                self.plib.destroy_namespace(region=region)
                size = self.plib.run_ndctl_list_val(dev, 'size')
                if size < (3 * 64 * 1024 * 1024):
                    self.log.warn('Skipping region due to insufficient memory')
                    continue
                for _ in range(3):
                    self.plib.create_namespace(region=region,
                                               mode='fsdax',
                                               size='64M')

            namespaces = self.plib.run_ndctl_list('-N -r %s' % region)
            if not os.path.exists(
                    '/sys/bus/nd/devices/namespace0.0/numa_node'):
                self.fail("Numa node entries not found!")
            for val in namespaces:
                ns_name = self.plib.run_ndctl_list_val(val, 'dev')
                numa = genio.read_one_line('/sys/bus/nd/devices/%s/numa_node' %
                                           ns_name)
                # Check numa config in ndctl and sys interface
                if len(
                        self.plib.run_ndctl_list('-N -n %s -U %s' %
                                                 (ns_name, numa))) != 1:
                    self.fail('Numa mismatch between ndctl and sys interface')

    @avocado.fail_on(pmem.PMemException)
    def test_label_read_write(self):
        region = self.get_default_region()
        if (self.plib.is_region_legacy(region)):
            self.cancel("Legacy config skipping the test")

        nmem = "nmem%s" % re.findall(r'\d+', region)[0]
        self.log.info("Using %s for testing labels", region)
        self.plib.disable_region(name=region)
        self.log.info("Filling zeros to start test")
        if process.system('%s zero-labels %s' % (self.ndctl, nmem),
                          shell=True):
            self.fail("Label zero-fill failed")

        self.plib.enable_region(name=region)
        self.plib.create_namespace(region=region)
        self.log.info("Storing labels with a namespace")
        old_op = process.system_output('%s check-labels %s' %
                                       (self.ndctl, nmem),
                                       shell=True)
        if process.system('%s read-labels %s -o output' % (self.ndctl, nmem),
                          shell=True):
            self.fail("Label read failed")

        self.log.info("Refilling zeroes before a restore")
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.disable_region(name=region)
        if process.system('%s zero-labels %s' % (self.ndctl, nmem),
                          shell=True):
            self.fail("Label zero-fill failed after read")

        self.log.info("Re-storing labels with a namespace")
        if process.system('%s write-labels %s -i output' % (self.ndctl, nmem),
                          shell=True):
            self.fail("Label write failed")
        self.plib.enable_region(name=region)

        self.log.info("Checking mismatch after restore")
        new_op = process.system_output('%s check-labels %s' %
                                       (self.ndctl, nmem),
                                       shell=True)
        if new_op != old_op:
            self.fail("Label read and write mismatch")

        self.log.info("Checking created namespace after restore")
        if len(self.plib.run_ndctl_list('-N -r %s' % region)) != 1:
            self.fail("Created namespace not found after label restore")

    @avocado.fail_on(pmem.PMemException)
    def test_daxctl_list(self):
        """
        Test daxctl list
        """
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region, mode='devdax')
        index = re.findall(r'\d+', region)[0]
        vals = self.plib.run_daxctl_list('-r %s' % (index))
        if len(vals) != 1:
            self.fail('Failed daxctl list')
        self.log.info('Created dax device %s', vals)

    @avocado.fail_on(pmem.PMemException)
    def test_region_capabilities(self):
        """
        Test region capabilities
        """
        self.plib.enable_region()
        self.plib.disable_namespace()
        self.plib.destroy_namespace()
        regions = self.plib.run_ndctl_list('-R -C')
        for region in regions:
            cap = self.plib.run_ndctl_list_val(region, 'capabilities')
            sec_sizes = []
            fsdax_align = []
            devdax_align = []
            for typ in cap:
                mode = self.plib.run_ndctl_list_val(typ, 'mode')
                if mode == 'fsdax':
                    fsdax_align = self.plib.run_ndctl_list_val(
                        typ, 'alignments')
                elif mode == 'devdax':
                    devdax_align = self.plib.run_ndctl_list_val(
                        typ, 'alignments')
                elif mode == 'sector':
                    sec_sizes = self.plib.run_ndctl_list_val(
                        typ, 'sector_sizes')
            reg_name = self.plib.run_ndctl_list_val(region, 'dev')
            self.log.info("Creating namespaces with possible sizes")
            for size in sec_sizes:
                self.plib.create_namespace(region=reg_name,
                                           mode='sector',
                                           sector_size=size)
                self.plib.destroy_namespace(region=reg_name, force=True)
            for size in fsdax_align:
                self.plib.create_namespace(region=reg_name,
                                           mode='fsdax',
                                           align=size)
                self.plib.destroy_namespace(region=reg_name, force=True)
            for size in devdax_align:
                self.plib.create_namespace(region=reg_name,
                                           mode='devdax',
                                           align=size)
                self.plib.destroy_namespace(region=reg_name, force=True)

    @avocado.fail_on(pmem.PMemException)
    def test_daxctl_memhotplug_unplug(self):
        """
        Test devdax memory hotplug/unplug
        """
        for cmd in ["reconfigure-device", "offline-memory", "online-memory"]:
            if not self.plib.check_daxctl_subcmd(cmd):
                self.cancel("Binary does not support %s" % cmd)
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region, mode='devdax')
        daxdev = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'chardev')
        old_mem = memory.meminfo.MemTotal.b
        dev_prop = self.plib.reconfigure_dax_device(daxdev, mode="system-ram")
        self.log.info("Reconfigured device %s", dev_prop)
        new_mem = memory.meminfo.MemTotal.b
        self.log.info("Memory Before:%s, Memory After:%s", old_mem, new_mem)
        if new_mem <= old_mem:
            self.log.warn("Memorysize not increased %s<=%s", new_mem, old_mem)
        self.plib.set_dax_memory_offline(daxdev)
        unplug_mem = memory.meminfo.MemTotal.b
        if unplug_mem != old_mem:
            self.fail("Memory after unplug is not same as system memory")
        self.log.info("Memory restored to base memory after unplug")
        self.plib.set_dax_memory_online(daxdev)
        hplug_mem = memory.meminfo.MemTotal.b
        if hplug_mem != new_mem:
            self.fail("Memory after hotplug is not same as device size memory")
        self.log.info("Memory hotplug successful with pmem device")
        self.log.info("Restoring pmem device in devdax mode")
        self.plib.set_dax_memory_offline(daxdev)
        self.plib.reconfigure_dax_device(daxdev, mode="devdax")

    @avocado.fail_on(pmem.PMemException)
    def write_read_infoblock(self, ns_name, align='', size=''):
        """
        Write_infoblock on given namespace
        """
        self.plib.write_infoblock(namespace=ns_name,
                                  align=align,
                                  size=size,
                                  mode='devdax')
        read_out = self.plib.read_infoblock(namespace=ns_name)
        if align:
            if align != int(self.plib.run_ndctl_list_val(read_out[0],
                                                         'align')):
                self.fail("Alignment has not changed")
        return read_out[0]

    @avocado.fail_on(pmem.PMemException)
    def test_write_infoblock_supported_align(self):
        """
        Test write_infoblock with align size
        """
        if not self.plib.check_ndctl_subcmd("write-infoblock"):
            self.cancel("Binary does not support write-infoblock")
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region, mode='devdax')
        ns_name = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')
        self.plib.disable_namespace(namespace=ns_name)
        self.write_read_infoblock(ns_name, align=self.get_size_alignval())
        self.plib.enable_namespace(namespace=ns_name)

    @avocado.fail_on(pmem.PMemException)
    def test_write_infoblock_unalign(self):
        """
        Test write_infoblock with unsupported align size
        """
        if not self.plib.check_ndctl_subcmd("write-infoblock"):
            self.cancel("Binary does not support write-infoblock")
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region, mode='devdax')
        ns_name = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')
        self.plib.disable_namespace(namespace=ns_name)
        self.write_read_infoblock(ns_name,
                                  align=self.get_unsupported_alignval())
        try:
            self.plib.enable_namespace(namespace=ns_name)
        except pmem.PMemException:
            self.log.info("Failed as expected")
        else:
            self.log.info(self.plib.run_ndctl_list())
            self.fail("Enabling namespace must have failed")

        idle_ns = self.plib.run_ndctl_list('-Ni -r %s' % region)
        if len(idle_ns) > 1:
            found = False
            for namespace in idle_ns:
                if int(self.plib.run_ndctl_list_val(namespace, 'size')) != 0:
                    found = True
                    break
        else:
            self.fail("Created namespace is not found")
        if not found:
            self.fail("Namespace with infoblock written not found")

        self.plib.destroy_namespace(namespace=ns_name, force=True)

    @avocado.fail_on(pmem.PMemException)
    def test_write_infoblock_align_default(self):
        """
        Test write_infoblock with align size
        """
        if not self.plib.check_ndctl_subcmd("write-infoblock"):
            self.cancel("Binary does not support write-infoblock")
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region, mode='devdax')
        ns_name = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')
        align = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'align')
        self.plib.disable_namespace(namespace=ns_name)
        write_block = self.write_read_infoblock(ns_name)
        if align != self.plib.run_ndctl_list_val(write_block, 'align'):
            self.fail("Alignment is not same as default alignment")

    @avocado.fail_on(pmem.PMemException)
    def test_write_infoblock_size(self):
        """
        Test write_infoblock with align size
        """
        if not self.plib.check_ndctl_subcmd("write-infoblock"):
            self.cancel("Binary does not support write-infoblock")
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region, mode='devdax')
        ns_name = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')
        size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'size')
        self.plib.disable_namespace(namespace=ns_name)
        align = self.get_size_alignval()
        size = size - align
        self.write_read_infoblock(ns_name, size=size, align=align)
        self.plib.enable_namespace(namespace=ns_name)

    @avocado.fail_on(pmem.PMemException)
    def test_write_infoblock_size_unaligned(self):
        """
        Test write_infoblock with align size
        """
        if not self.plib.check_ndctl_subcmd("write-infoblock"):
            self.cancel("Binary does not support write-infoblock")
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region, mode='devdax')
        ns_name = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')
        size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'size')
        self.plib.disable_namespace(namespace=ns_name)
        align = memory.get_page_size()
        size = size - align
        self.write_read_infoblock(ns_name, size=size, align=align)
        try:
            self.plib.enable_namespace(namespace=ns_name)
        except pmem.PMemException:
            self.log.info("Failed as expected")
        else:
            self.log.info(self.plib.run_ndctl_list())
            self.fail("Enabling namespace must have failed")

    @avocado.fail_on(pmem.PMemException)
    def test_sector_write(self):
        """
        Test write on a sector mode device
        """
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region,
                                   mode='sector',
                                   sector_size='512')
        self.disk = '/dev/%s' % self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'blockdev')
        size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'size')
        self.part = partition.Partition(self.disk)
        self.part.mkfs(fstype='xfs',
                       args='-b size=%s -s size=512' % memory.get_page_size())
        mnt_path = self.params.get('mnt_point', default='/pmemS')
        if not os.path.exists(mnt_path):
            os.makedirs(mnt_path)
        self.part.mount(mountpoint=mnt_path)
        self.log.info("Test will run on %s", mnt_path)
        fio_job = self.params.get('fio_job', default='sector-fio.job')
        cmd = '%s --directory %s --filename mmap-pmem --size %s %s' % (
            self.build_fio(), mnt_path, size // 2, self.get_data(fio_job))
        if process.system(cmd, ignore_status=True):
            self.fail("FIO mmap workload on fsdax failed")

    @avocado.fail_on(pmem.PMemException)
    def test_fsdax_write(self):
        """
        Test filesystem DAX with a FIO workload
        """
        region = self.get_default_region()
        self.plib.create_namespace(region=region, mode='fsdax')
        self.disk = '/dev/%s' % self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'blockdev')
        size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'size')
        self.part = partition.Partition(self.disk)
        self.part.mkfs(fstype='xfs',
                       args='-b size=%s -s size=512 %s' %
                       (memory.get_page_size(), self.reflink))
        mnt_path = self.params.get('mnt_point', default='/pmem')
        if not os.path.exists(mnt_path):
            os.makedirs(mnt_path)
        self.part.mount(mountpoint=mnt_path, args='-o dax')
        self.log.info("Test will run on %s", mnt_path)
        fio_job = self.params.get('fio_job', default='ndctl-fio.job')
        cmd = '%s --directory %s --filename mmap-pmem --size %s %s' % (
            self.build_fio(), mnt_path, size // 2, self.get_data(fio_job))
        if process.system(cmd, ignore_status=True):
            self.fail("FIO mmap workload on fsdax failed")

    @avocado.fail_on(pmem.PMemException)
    def test_map_sync(self):
        """
        Test MAP_SYNC flag with sample mmap write
        """
        region = self.get_default_region()
        self.plib.create_namespace(region=region, mode='fsdax')
        self.disk = '/dev/%s' % self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'blockdev')
        self.part = partition.Partition(self.disk)
        self.part.mkfs(fstype='xfs',
                       args='-b size=%s -s size=512 %s' %
                       (memory.get_page_size(), self.reflink))
        mnt_path = self.params.get('mnt_point', default='/pmem_map')
        if not os.path.exists(mnt_path):
            os.makedirs(mnt_path)
        self.part.mount(mountpoint=mnt_path, args='-o dax')
        self.log.info("Testing MAP_SYNC on %s", mnt_path)
        src_file = os.path.join(self.teststmpdir, 'map_sync.c')
        shutil.copyfile(self.get_data('map_sync.c'), src_file)
        process.system('gcc %s -o map_sync' % src_file)
        process.system('fallocate -l 64k %s/new_file' % mnt_path)
        if process.system('./map_sync %s/new_file' % mnt_path,
                          ignore_status=True):
            self.fail('Write with MAP_SYNC flag failed')

    @avocado.fail_on(pmem.PMemException)
    def test_devdax_write(self):
        """
        Test device DAX with a daxio binary
        """
        region = self.get_default_region()
        self.plib.create_namespace(region=region, mode='devdax')
        daxdev = "/dev/%s" % self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'chardev')
        if process.system("%s -b no -i /dev/urandom -o %s" %
                          (self.get_data("daxio.static"), daxdev),
                          ignore_status=True):
            self.fail("DAXIO write on devdax failed")

    @avocado.fail_on(pmem.PMemException)
    def tearDown(self):
        if self.part:
            self.part.unmount()
        if self.disk:
            self.log.info("Removing the FS meta created on %s", self.disk)
            delete_fs = "dd if=/dev/zero bs=1M count=1024 of=%s" % self.disk
            if process.system(delete_fs, shell=True, ignore_status=True):
                self.fail("Failed to delete filesystem on %s" % self.disk)

        if not self.preserve_setup:
            if self.plib.run_ndctl_list('-N'):
                self.plib.destroy_namespace(force=True)
            self.plib.disable_region()
 def setUp(self):
     """
     To check and install dependencies for the test
     """
     self.peer_ip = self.params.get("peer_ip", default="")
     self.peer_user = self.params.get("peer_user_name", default="root")
     self.peer_password = self.params.get("peer_password",
                                          '*',
                                          default="None")
     interfaces = netifaces.interfaces()
     self.iface = self.params.get("interface", default="")
     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)
     self.session = Session(self.peer_ip,
                            user=self.peer_user,
                            password=self.peer_password)
     smm = SoftwareManager()
     detected_distro = distro.detect()
     pkgs = ["gcc", "autoconf", "perl", "m4", "git-core", "automake"]
     if detected_distro.name == "Ubuntu":
         pkgs.extend(["libsctp1", "libsctp-dev", "lksctp-tools"])
     else:
         pkgs.extend(["lksctp-tools", "lksctp-tools-devel"])
     for pkg in pkgs:
         if not smm.check_installed(pkg) and not smm.install(pkg):
             self.cancel("%s package is need to test" % pkg)
         cmd = "%s install %s" % (smm.backend.base_command, pkg)
         output = self.session.cmd(cmd)
         if not output.exit_status == 0:
             self.cancel(
                 "unable to install the package %s on peer machine " % pkg)
     if self.peer_ip == "":
         self.cancel("%s peer machine is not available" % self.peer_ip)
     self.mtu = self.params.get("mtu", default=1500)
     self.peerinfo = PeerInfo(self.peer_ip,
                              peer_user=self.peer_user,
                              peer_password=self.peer_password)
     self.peer_interface = self.peerinfo.get_peer_interface(self.peer_ip)
     if not self.peerinfo.set_mtu_peer(self.peer_interface, self.mtu):
         self.cancel("Failed to set mtu in peer")
     if not configure_network.set_mtu_host(self.iface, self.mtu):
         self.cancel("Failed to set mtu in host")
     uperf_download = self.params.get("uperf_download",
                                      default="https:"
                                      "//github.com/uperf/uperf/"
                                      "archive/master.zip")
     tarball = self.fetch_asset("uperf.zip",
                                locations=[uperf_download],
                                expire='7d')
     archive.extract(tarball, self.teststmpdir)
     self.uperf_dir = os.path.join(self.teststmpdir, "uperf-master")
     cmd = "scp -r %s %s@%s:/tmp" % (self.uperf_dir, self.peer_user,
                                     self.peer_ip)
     if process.system(cmd, shell=True, ignore_status=True) != 0:
         self.cancel("unable to copy the uperf into peer machine")
     cmd = "cd /tmp/uperf-master;autoreconf -fi;./configure ppc64le;make"
     output = self.session.cmd(cmd)
     if not output.exit_status == 0:
         self.cancel("Unable to compile Uperf into peer machine")
     self.uperf_run = str(self.params.get("UPERF_SERVER_RUN", default=0))
     if self.uperf_run == '1':
         cmd = "/tmp/uperf-master/src/uperf -s &"
         cmd = self.session.get_raw_ssh_command(cmd)
         self.obj = SubProcess(cmd)
         self.obj.start()
     os.chdir(self.uperf_dir)
     process.system('autoreconf -fi', shell=True)
     process.system('./configure ppc64le', shell=True)
     build.make(self.uperf_dir)
     self.expected_tp = self.params.get("EXPECTED_THROUGHPUT", default="85")
 def setUp(self):
     '''
     To check and install dependencies for the test
     '''
     smm = SoftwareManager()
     pkgs = ["ethtool", "net-tools"]
     detected_distro = distro.detect()
     if detected_distro.name == "Ubuntu":
         pkgs.extend(["openssh-client", "iputils-ping"])
     elif detected_distro.name == "SuSE":
         pkgs.extend(["openssh", "iputils"])
     else:
         pkgs.extend(["openssh-clients", "iputils"])
     for pkg in pkgs:
         if not smm.check_installed(pkg) and not smm.install(pkg):
             self.cancel("%s package is need to test" % pkg)
     interfaces = netifaces.interfaces()
     interface = self.params.get("interface")
     if interface not in interfaces:
         self.cancel("%s interface is not available" % interface)
     self.iface = interface
     self.ipaddr = self.params.get("host_ip", default="")
     self.netmask = self.params.get("netmask", default="")
     local = LocalHost()
     self.networkinterface = NetworkInterface(self.iface, local)
     try:
         self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
         self.networkinterface.save(self.ipaddr, self.netmask)
     except Exception:
         self.networkinterface.save(self.ipaddr, self.netmask)
     self.networkinterface.bring_up()
     if not wait.wait_for(self.networkinterface.is_link_up, timeout=120):
         self.fail("Link up of interface is taking longer than 120 seconds")
     self.peer = self.params.get("peer_ip")
     if not self.peer:
         self.cancel("No peer provided")
     self.mtu = self.params.get("mtu", default=1500)
     self.peer_public_ip = self.params.get("peer_public_ip", default="")
     self.peer_user = self.params.get("peer_user", default="root")
     self.peer_password = self.params.get("peer_password",
                                          '*',
                                          default=None)
     if 'scp' or 'ssh' in str(self.name.name):
         self.session = Session(self.peer,
                                user=self.peer_user,
                                password=self.peer_password)
         if not self.session.connect():
             self.cancel("failed connecting to peer")
     self.remotehost = RemoteHost(self.peer,
                                  self.peer_user,
                                  password=self.peer_password)
     self.peer_interface = self.remotehost.get_interface_by_ipaddr(
         self.peer).name
     self.peer_networkinterface = NetworkInterface(self.peer_interface,
                                                   self.remotehost)
     self.remotehost_public = RemoteHost(self.peer_public_ip,
                                         self.peer_user,
                                         password=self.peer_password)
     self.peer_public_networkinterface = NetworkInterface(
         self.peer_interface, self.remotehost_public)
     self.mtu = self.params.get("mtu", default=1500)
     self.mtu_set()
     if self.networkinterface.ping_check(self.peer, count=5) is not None:
         self.cancel("No connection to peer")
    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.disk_type = self.params.get('disk_type', default='')
        fs_args = self.params.get('fs_args', default='')
        mnt_args = self.params.get('mnt_args', default='')
        self.fio_file = 'fiotest-image'

        self.fs_create = False
        self.lv_create = False
        self.raid_create = False
        self.devdax_file = None

        fstype = self.params.get('fs', default='')
        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")

        lv_needed = self.params.get('lv', default=False)
        raid_needed = self.params.get('raid', default=False)

        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 = ""

        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.disk = self.workdir

        self.dirs = self.disk
        if self.disk in disk.get_disks():
            if raid_needed:
                raid_name = '/dev/md/mdsraid'
                self.create_raid(self.disk, raid_name)
                self.raid_create = True
                self.disk = raid_name

            if lv_needed:
                self.disk = self.create_lv(self.disk)
                self.lv_create = True
                self.dirs = self.disk

            if fstype:
                self.dirs = self.workdir
                self.create_fs(self.disk, self.dirs, fstype, fs_args, mnt_args)
                self.fs_create = True

        build.make(self.sourcedir, extra_args=fio_flags)
    def setUp(self):

        # Check for basic utilities
        sm = SoftwareManager()
        detected_distro = distro.detect()
        deps = ['gcc', 'make', 'patch']
        cpuinfo = genio.read_file("/proc/cpuinfo").strip()
        if detected_distro.name == "Ubuntu":
            deps += ['libpthread-stubs0-dev', 'git']
        elif detected_distro.name == "SuSE":
            deps += ['glibc-devel-static', 'git-core']
        else:
            deps += ['glibc-static', 'git']

        for package in deps:
            if not sm.check_installed(package) and not sm.install(package):
                self.cancel(' %s is needed for the test to be run' % package)

        kernel.check_version("2.6.16")

        if detected_distro.name == "Ubuntu":
            op = glob.glob("/usr/lib/*/libpthread.a")
        else:
            op = glob.glob("/usr/lib*/libpthread.a")

        if not op:
            self.cancel("libpthread.a is required!!!"
                        "\nTry installing glibc-static")

        self.page_sizes = ['16']
        if 'POWER9' in cpuinfo and 'PowerNV' in cpuinfo:
            self.page_sizes = ['2', '1024']

        # Get arguments:
        self.hugetlbfs_dir = self.params.get('hugetlbfs_dir', default=None)
        pages_requested = self.params.get('pages_requested', default=20)

        # Check hugepages:
        pages_available = 0
        if os.path.exists('/proc/sys/vm/nr_hugepages'):

            Hugepages_support = genio.read_file("/proc/meminfo").rstrip("\n")

            if 'HugePages_' not in Hugepages_support:
                self.cancel("No Hugepages Configured")
        else:
            self.cancel("Kernel does not support hugepages")

        if not self.hugetlbfs_dir:
            self.hugetlbfs_dir = os.path.join(self.teststmpdir, 'hugetlbfs')
            os.makedirs(self.hugetlbfs_dir)

        for hp_size in self.page_sizes:
            if process.system('mount -t hugetlbfs -o pagesize=%sM none %s' %
                              (hp_size, self.hugetlbfs_dir),
                              sudo=True,
                              ignore_status=True):
                self.cancel("hugetlbfs mount failed")
            genio.write_file(
                '/sys/kernel/mm/hugepages/hugepages-%skB/nr_hugepages' %
                str(int(hp_size) * 1024), str(pages_requested))
            pages_available = int(
                genio.read_file('/sys/kernel/mm/hugepages/huge'
                                'pages-%skB/nr_hugepages' %
                                str(int(hp_size) * 1024).strip()))
            if pages_available < pages_requested:
                self.cancel('%d pages available, < %d pages requested' %
                            (pages_available, pages_requested))

        git.get_repo('https://github.com/libhugetlbfs/libhugetlbfs.git',
                     destination_dir=self.workdir)
        os.chdir(self.workdir)
        patch = self.params.get('patch', default='elflink.patch')
        process.run('patch -p1 < %s' % self.get_data(patch), shell=True)

        build.make(self.workdir, extra_args='BUILDTYPE=NATIVEONLY')
    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)

        if self.run_type == 'git':
            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")
        else:
            dist_name = detected_distro.name.lower()
            if dist_name == 'suse':
                dist_name = 'sles'
            rpm_check = "htx%s%s" % (dist_name, detected_distro.version)
            skip_install = False
            ins_htx = process.system_output('rpm -qa | grep htx',
                                            shell=True,
                                            ignore_status=True).decode()
            if ins_htx:
                if not smm.check_installed(rpm_check):
                    self.log.info("Clearing existing HTX rpm")
                    process.system('rpm -e %s' % ins_htx,
                                   shell=True,
                                   ignore_status=True)
                    if os.path.exists('/usr/lpp/htx'):
                        shutil.rmtree('/usr/lpp/htx')
                else:
                    self.log.info("Using existing HTX")
                    skip_install = True
            if not skip_install:
                rpm_loc = self.params.get('rpm_link', default=None)
                if rpm_loc:
                    if process.system('rpm -ivh --nodeps %s '
                                      '--force' % rpm_loc,
                                      shell=True,
                                      ignore_status=True):
                        self.cancel("Installing rpm failed")
                else:
                    self.cancel("RPM link is required for RPM run type")
        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):
     '''
     To check and install dependencies for the test
     '''
     detected_distro = distro.detect()
     smm = SoftwareManager()
     depends = []
     # 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 detected_distro.name == "Ubuntu":
         depends.extend(["openssh-client", "iputils-ping"])
     elif detected_distro.name in ["rhel", "fedora", "centos", "redhat"]:
         depends.extend(["openssh-clients", "iputils"])
     else:
         depends.extend(["openssh", "iputils"])
     for pkg in depends:
         if not smm.check_installed(pkg) and not smm.install(pkg):
             self.cancel("%s package is need to test" % pkg)
     interfaces = netifaces.interfaces()
     self.user = self.params.get("user_name", default="root")
     self.host_interfaces = self.params.get("host_interfaces",
                                            default="").split(",")
     if not self.host_interfaces:
         self.cancel("user should specify host interfaces")
     self.peer_interfaces = self.params.get("peer_interfaces",
                                            default="").split(",")
     for self.host_interface in self.host_interfaces:
         if self.host_interface not in interfaces:
             self.cancel("interface is not available")
     self.peer_first_ipinterface = self.params.get("peer_ip", default="")
     if not self.peer_interfaces or self.peer_first_ipinterface == "":
         self.cancel("peer machine should available")
     msg = "ip addr show  | grep %s | grep -oE '[^ ]+$'"\
           % self.peer_first_ipinterface
     cmd = "ssh %s@%s %s" % (self.user, self.peer_first_ipinterface, msg)
     self.peer_first_interface = process.system_output(cmd,
                                                       shell=True).strip()
     if self.peer_first_interface == "":
         self.fail("test failed because peer interface can not retrieved")
     self.bond_name = self.params.get("bond_name", default="tempbond")
     self.bond_status = "cat /proc/net/bonding/%s" % self.bond_name
     self.bond_dir = os.path.join("/sys/class/net/", self.bond_name)
     self.mode = self.params.get("bonding_mode", default="")
     if self.mode == "":
         self.cancel("test skipped because mode not specified")
     self.host_ips = []
     self.peer_ips = [self.peer_first_ipinterface]
     for val in self.host_interfaces:
         cmd = "ip -f inet -o addr show %s | awk '{print $4}' | cut -d /\
               -f1" % val
         local_ip = process.system_output(cmd, shell=True).strip()
         if local_ip == "" and val == self.host_interfaces[0]:
             self.fail("test failed because local ip can not retrieved")
         self.host_ips.append(local_ip)
     for val in self.peer_interfaces:
         msg = "ip -f inet -o addr show %s | awk '{print $4}' | cut -d /\
               -f1" % val
         cmd = "ssh %s@%s \"%s\""\
               % (self.user, self.peer_first_ipinterface, msg)
         peer_ip = process.system_output(cmd, shell=True).strip()
         cmd = 'echo %s | cut -d " " -f4' % peer_ip
         peer_ip = process.system_output(cmd, shell=True).strip()
         if peer_ip == "" and val == self.peer_first_interface:
             self.fail("test failed because peer ip can not retrieved")
         self.peer_ips.append(peer_ip)
     self.peer_interfaces.insert(0, self.peer_first_interface)
     self.net_mask = []
     stf = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     for val1, val2 in map(None, self.host_interfaces, self.host_ips):
         mask = ""
         if val2:
             tmp = fcntl.ioctl(stf.fileno(), 0x891b, struct.pack('256s',
                                                                 val1))
             mask = socket.inet_ntoa(tmp[20:24]).strip('\n')
         self.net_mask.append(mask)
     self.bonding_slave_file = "/sys/class/net/%s/bonding/slaves"\
                               % self.bond_name
     self.peer_bond_needed = self.params.get("peer_bond_needed",
                                             default=False)
     self.peer_wait_time = self.params.get("peer_wait_time", default=5)
     self.sleep_time = int(self.params.get("sleep_time", default=5))
     cmd = "route -n | grep %s | grep -w UG | awk "\
           "'{ print $2 }'" % self.host_interfaces[0]
     self.gateway = process.system_output(
         '%s' % cmd, shell=True)
Beispiel #44
0
class NdctlTest(Test):
    """
    Ndctl user space tooling for Linux, which handles NVDIMM devices.
    """
    def get_default_region(self):
        """
        Get the largest region if not provided
        """
        self.plib.enable_region()
        region = self.params.get('region', default=None)
        if region:
            return region
        regions = self.plib.run_ndctl_list('-R')
        regions = sorted(regions, key=lambda i: i['size'], reverse=True)
        return self.plib.run_ndctl_list_val(regions[0], 'dev')

    @staticmethod
    def get_size_alignval():
        """
        Return the size align restriction based on platform
        """
        if 'Hash' in genio.read_file('/proc/cpuinfo').rstrip('\t\r\n\0'):
            def_align = 16 * 1024 * 1024
        else:
            def_align = 2 * 1024 * 1024
        return def_align

    def build_fio(self):
        """
        Install fio or build if not possible
        """
        pkg = "fio"
        if process.system("which %s" % pkg, ignore_status=True):
            if not self.smm.check_installed(pkg) \
                    and not self.smm.install(pkg):
                for package in ["autoconf", "libtool", "make"]:
                    if not self.smm.check_installed(package) \
                            and not self.smm.install(package):
                        self.cancel(
                            "Fail to install %s required for this test."
                            "" % package)
                tarball = self.fetch_asset(
                    "http://brick.kernel.dk/snaps/fio-2.1.10.tar.gz")
                archive.extract(tarball, self.teststmpdir)
                fio_version = os.path.basename(tarball.split('.tar.')[0])
                sourcedir = os.path.join(self.teststmpdir, fio_version)
                build.make(sourcedir)
                return os.path.join(sourcedir, "fio")
        return pkg

    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([
                    'ruby2.5-rubygem-asciidoctor', 'libtool', 'libkmod-devel',
                    'libudev-devel', 'systemd-devel', 'libuuid-devel-static',
                    'libjson-c-devel', 'keyutils-devel', 'kmod-bash-completion'
                ])
            elif self.dist.name == 'rhel':
                deps.extend([
                    'rubygem-asciidoctor', 'automake', 'libtool', 'kmod-devel',
                    'libuuid-devel', 'json-c-devel', 'systemd-devel',
                    'keyutils-libs-devel', 'jq', 'parted', 'libtool'
                ])
            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)

            locations = ["https://github.com/pmem/ndctl/archive/master.zip"]
            tarball = self.fetch_asset("ndctl.zip",
                                       locations=locations,
                                       expire='7d')
            archive.extract(tarball, self.teststmpdir)
            os.chdir("%s/ndctl-master" % self.teststmpdir)
            process.run('./autogen.sh', sudo=True, shell=True)
            process.run(
                "./configure CFLAGS='-g -O2' --prefix=/usr "
                "--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")

    @avocado.fail_on(pmem.PMemException)
    def test_bus_ids(self):
        """
        Test the bus id info
        """
        vals = self.plib.run_ndctl_list('-B')
        if not vals:
            self.fail('Failed to fetch bus IDs')
        self.log.info('Available Bus provider IDs: %s', vals)

    @avocado.fail_on(pmem.PMemException)
    def test_dimms(self):
        """
        Test the dimms info
        """
        vals = self.plib.run_ndctl_list('-D')
        if not vals:
            self.fail('Failed to fetch DIMMs')
        self.log.info('Available DIMMs: %s', vals)

    @avocado.fail_on(pmem.PMemException)
    def test_regions(self):
        """
        Test the regions info
        """
        self.plib.disable_region()
        old = self.plib.run_ndctl_list('-R')
        self.plib.enable_region()
        new = self.plib.run_ndctl_list('-R')
        if len(new) <= len(old):
            self.fail('Failed to fetch regions')
        self.log.info('Available regions: %s', new)

    @avocado.fail_on(pmem.PMemException)
    def test_namespace(self):
        """
        Test namespace
        """
        self.plib.enable_region()
        regions = self.plib.run_ndctl_list('-R')
        for val in regions:
            region = self.plib.run_ndctl_list_val(val, 'dev')
            self.plib.disable_namespace(region=region)
            self.plib.destroy_namespace(region=region)
            self.plib.create_namespace(region=region)

        namespaces = self.plib.run_ndctl_list('-N')
        self.log.info('Created namespace %s', namespaces)

    @avocado.fail_on(pmem.PMemException)
    def test_disable_enable_ns(self):
        """
        Test enable disable namespace
        """
        region = self.get_default_region()
        if (not self.plib.is_region_legacy(region)):
            for _ in range(0, 3):
                self.plib.create_namespace(region=region, size='128M')
        namespaces = self.plib.run_ndctl_list('-N')
        ns_names = []
        for ns in namespaces:
            ns_names.append(self.plib.run_ndctl_list_val(ns, 'dev'))
        ns_names.append('all')

        for namespace in ns_names:
            self.plib.disable_namespace(namespace=namespace)
            self.plib.enable_namespace(namespace=namespace)

    @avocado.fail_on(pmem.PMemException)
    def test_namespace_modes(self):
        """
        Create  different namespace types
        """
        failed_modes = []
        region = self.get_default_region()
        self.log.info("Using %s for different namespace modes", region)
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        for mode in self.modes:
            self.plib.create_namespace(region=region, mode=mode)
            ns_json = self.plib.run_ndctl_list()[0]
            created_mode = self.plib.run_ndctl_list_val(ns_json, 'mode')
            if mode != created_mode:
                failed_modes.append(mode)
                self.log.error("Expected mode %s, Got %s", mode, created_mode)
            else:
                self.log.info("Namespace with %s mode: %s", mode, ns_json)
            ns_name = self.plib.run_ndctl_list_val(ns_json, 'dev')
            self.plib.disable_namespace(namespace=ns_name, region=region)
            self.plib.destroy_namespace(namespace=ns_name, region=region)

        if failed_modes:
            self.fail("Namespace for %s mode failed!" % failed_modes)

    @avocado.fail_on(pmem.PMemException)
    def test_namespace_devmap(self):
        """
        Test metadata device mapping option with a namespace
        """
        region = self.get_default_region()
        m_map = self.params.get('map', default='mem')
        size_align = self.get_size_alignval()
        # Size input in MB
        namespace_size = int(self.params.get('size', default=128) * 1048576)
        if namespace_size and (namespace_size % size_align):
            self.cancel("Size value %s not %s aligned \n" %
                        (namespace_size, size_align))
        self.log.info("Using %s for checking device mapping", region)
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region,
                                   mode=self.mode_to_use,
                                   memmap=m_map,
                                   size='%s' % namespace_size)
        self.log.info("Validating device mapping")
        map_val = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list('-r %s -N' % region)[0], 'map')
        if map_val != m_map:
            self.fail("Expected map:%s, Got %s" % (m_map, map_val))
        else:
            self.log.info("Metadata mapped as expected")

    def multiple_namespaces_region(self, region):
        """
        Test multiple namespace with single region
        """
        namespace_size = self.params.get('size', default=None)
        size_align = self.get_size_alignval()
        slot_count = self.plib.get_slot_count(region)
        self.log.info("Using %s for muliple namespace regions", region)
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        if namespace_size and ((namespace_size % size_align) != 0):
            self.cancel("Size value not %d aligned %d \n", size_align,
                        namespace_size)

        region_size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list('-r %s' % region)[0], 'size')
        if not namespace_size:
            namespace_size = region_size // slot_count
            # Now align the namespace size
            namespace_size = (namespace_size // size_align) * size_align
        else:
            slot_count = region_size // namespace_size

        self.log.info("Creating %s namespaces", slot_count)
        for count in range(0, slot_count):
            self.plib.create_namespace(region=region,
                                       mode=self.mode_to_use,
                                       size=namespace_size)
            self.log.info("Namespace %s created", count + 1)

    @avocado.fail_on(pmem.PMemException)
    def test_multiple_namespaces_region(self):
        """
        Test multiple namespace with single region
        """
        region = self.get_default_region()
        if (self.plib.is_region_legacy(region)):
            self.cancel("Legacy config skipping the test")
        self.multiple_namespaces_region(region)

    @avocado.fail_on(pmem.PMemException)
    def test_multiple_ns_multiple_region(self):
        """
        Test multiple namespace with multiple region
        """
        self.plib.enable_region()
        if len(self.plib.run_ndctl_list('-R')) <= 1:
            self.cancel("Test not applicable without multiple regions")
        regions = self.plib.run_ndctl_list('-R')
        self.plib.disable_namespace()
        self.plib.destroy_namespace()
        for val in regions:
            region = self.plib.run_ndctl_list_val(val, 'dev')
            if (self.plib.is_region_legacy(region)):
                self.cancel("Legacy config skipping the test")
            self.multiple_namespaces_region(region)

    @avocado.fail_on(pmem.PMemException)
    def test_multiple_ns_modes_region(self):
        """
        Test multiple namespace modes with single region
        """
        region = self.get_default_region()
        if (self.plib.is_region_legacy(region)):
            self.cancel("Legacy config skipping the test")
        self.log.info("Using %s for muliple namespace regions", region)
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list('-r %s' % region)[0], 'size')
        if size < (len(self.modes) * 64 * 1024 * 1024):
            self.cancel('Not enough memory to create namespaces')
        for mode in self.modes:
            self.plib.create_namespace(region=region, mode=mode, size='64M')
            self.log.info("Namespace of type %s created", mode)

    @avocado.fail_on(pmem.PMemException)
    def test_nslot_namespace(self):
        """
        Test max namespace with nslot value
        """
        region = self.get_default_region()
        if (self.plib.is_region_legacy(region)):
            self.cancel("Legacy config skipping the test")
        size_align = self.get_size_alignval()
        slot_count = self.plib.get_slot_count(region)
        self.log.info("Using %s for max namespace creation", region)
        self.plib.disable_namespace()
        self.plib.destroy_namespace()
        region_size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list('-r %s' % region)[0], 'size')
        namespace_size = region_size // slot_count
        # Now align the namespace size
        namespace_size = (namespace_size // size_align) * size_align

        self.log.info("Creating %s namespace", slot_count)
        for count in range(0, slot_count):
            self.plib.create_namespace(region=region,
                                       mode='fsdax',
                                       size=namespace_size)
            self.log.info("Namespace %s created", count)

    @avocado.fail_on(pmem.PMemException)
    def test_namespace_reconfigure(self):
        """
        Test namespace reconfiguration
        """
        region = self.get_default_region()
        self.log.info("Using %s for reconfiguring namespace", region)
        self.plib.disable_namespace()
        self.plib.destroy_namespace()
        self.plib.create_namespace(region=region, mode='fsdax', align='64k')
        old_ns = self.plib.run_ndctl_list()[0]
        old_ns_dev = self.plib.run_ndctl_list_val(old_ns, 'dev')
        self.log.info("Re-configuring namespace %s", old_ns_dev)
        self.plib.create_namespace(region=region,
                                   mode='fsdax',
                                   name='test_ns',
                                   reconfig=old_ns_dev,
                                   force=True)
        new_ns = self.plib.run_ndctl_list()[0]
        self.log.info("Checking namespace changes")
        failed_vals = []
        for key, val in new_ns.items():
            if key in list(set(old_ns.keys()) - set(['uuid', 'dev'])):
                if old_ns[key] != val:
                    failed_vals.append({key: val})
            else:
                self.log.info("Newly added filed %s:%s", key, val)
        if failed_vals:
            self.fail("New namespace unexpected change(s): %s" % failed_vals)

    @avocado.fail_on(pmem.PMemException)
    def test_check_namespace(self):
        """
        Verify metadata for sector mode namespaces
        """
        region = self.get_default_region()
        self.plib.disable_namespace()
        self.plib.destroy_namespace()
        self.log.info("Creating sector namespace using %s", region)
        self.plib.create_namespace(region=region, mode='sector')
        ns_sec_dev = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list()[0], 'dev')
        self.plib.disable_namespace(namespace=ns_sec_dev)
        self.log.info("Checking BTT metadata")
        if process.system("%s check-namespace %s" % (self.ndctl, ns_sec_dev),
                          ignore_status=True):
            self.fail("Failed to check namespace metadata")

    @avocado.fail_on(pmem.PMemException)
    def test_check_numa(self):
        self.plib.enable_region()
        regions = self.plib.run_ndctl_list('-R')
        if not os.path.exists('/sys/bus/nd/devices/region0/numa_node'):
            self.fail("Numa node entries not found!")
        for val in regions:
            reg = self.plib.run_ndctl_list_val(val, 'dev')
            numa = genio.read_one_line('/sys/bus/nd/devices/%s/numa_node' %
                                       reg)
            # Check numa config in ndctl and sys interface
            if len(self.plib.run_ndctl_list('-r %s -R -U %s' %
                                            (reg, numa))) != 1:
                self.fail('Region mismatch between ndctl and sys interface')

    @avocado.fail_on(pmem.PMemException)
    def test_check_ns_numa(self):
        self.plib.enable_region()
        regions = self.plib.run_ndctl_list('-R')
        for dev in regions:
            region = self.plib.run_ndctl_list_val(dev, 'dev')
            if not self.plib.is_region_legacy(region):
                self.plib.disable_namespace(region=region)
                self.plib.destroy_namespace(region=region)
                for _ in range(3):
                    self.plib.create_namespace(region=region,
                                               mode='fsdax',
                                               size='128M')

            namespaces = self.plib.run_ndctl_list('-N -r %s' % region)
            if not os.path.exists(
                    '/sys/bus/nd/devices/namespace0.0/numa_node'):
                self.fail("Numa node entries not found!")
            for val in namespaces:
                ns_name = self.plib.run_ndctl_list_val(val, 'dev')
                numa = genio.read_one_line('/sys/bus/nd/devices/%s/numa_node' %
                                           ns_name)
                # Check numa config in ndctl and sys interface
                if len(
                        self.plib.run_ndctl_list('-N -n %s -U %s' %
                                                 (ns_name, numa))) != 1:
                    self.fail('Numa mismatch between ndctl and sys interface')

    @avocado.fail_on(pmem.PMemException)
    def test_label_read_write(self):
        region = self.get_default_region()
        if (self.plib.is_region_legacy(region)):
            self.cancel("Legacy config skipping the test")

        nmem = "nmem%s" % re.findall(r'\d+', region)[0]
        self.log.info("Using %s for testing labels", region)
        self.plib.disable_region(name=region)
        self.log.info("Filling zeros to start test")
        if process.system('%s zero-labels %s' % (self.ndctl, nmem),
                          shell=True):
            self.fail("Label zero-fill failed")

        self.plib.enable_region(name=region)
        self.plib.create_namespace(region=region)
        self.log.info("Storing labels with a namespace")
        old_op = process.system_output('%s check-labels %s' %
                                       (self.ndctl, nmem),
                                       shell=True)
        if process.system('%s read-labels %s -o output' % (self.ndctl, nmem),
                          shell=True):
            self.fail("Label read failed")

        self.log.info("Refilling zeroes before a restore")
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.disable_region(name=region)
        if process.system('%s zero-labels %s' % (self.ndctl, nmem),
                          shell=True):
            self.fail("Label zero-fill failed after read")

        self.log.info("Re-storing labels with a namespace")
        if process.system('%s write-labels %s -i output' % (self.ndctl, nmem),
                          shell=True):
            self.fail("Label write failed")
        self.plib.enable_region(name=region)

        self.log.info("Checking mismatch after restore")
        new_op = process.system_output('%s check-labels %s' %
                                       (self.ndctl, nmem),
                                       shell=True)
        if new_op != old_op:
            self.fail("Label read and write mismatch")

        self.log.info("Checking created namespace after restore")
        if len(self.plib.run_ndctl_list('-N -r %s' % region)) != 1:
            self.fail("Created namespace not found after label restore")

    @avocado.fail_on(pmem.PMemException)
    def test_daxctl_list(self):
        """
        Test daxctl list
        """
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region, mode='devdax')
        index = re.findall(r'\d+', region)[0]
        vals = self.plib.run_daxctl_list('-r %s' % (index))
        if len(vals) != 1:
            self.fail('Failed daxctl list')
        self.log.info('Created dax device %s', vals)

    @avocado.fail_on(pmem.PMemException)
    def test_sector_write(self):
        """
        Test write on a sector mode device
        """
        region = self.get_default_region()
        self.plib.disable_namespace(region=region)
        self.plib.destroy_namespace(region=region)
        self.plib.create_namespace(region=region,
                                   mode='sector',
                                   sector_size='512')
        self.disk = '/dev/%s' % self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'blockdev')
        size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'size')
        self.part = partition.Partition(self.disk)
        self.part.mkfs(fstype='xfs',
                       args='-b size=%s -s size=512' % memory.get_page_size())
        mnt_path = self.params.get('mnt_point', default='/pmemS')
        if not os.path.exists(mnt_path):
            os.makedirs(mnt_path)
        self.part.mount(mountpoint=mnt_path)
        self.log.info("Test will run on %s", mnt_path)
        fio_job = self.params.get('fio_job', default='sector-fio.job')
        cmd = '%s --directory %s --filename mmap-pmem --size %s %s' % (
            self.build_fio(), mnt_path, size // 2, self.get_data(fio_job))
        if process.system(cmd, ignore_status=True):
            self.fail("FIO mmap workload on fsdax failed")

    @avocado.fail_on(pmem.PMemException)
    def test_fsdax_write(self):
        """
        Test filesystem DAX with a FIO workload
        """
        region = self.get_default_region()
        self.plib.create_namespace(region=region, mode='fsdax')
        self.disk = '/dev/%s' % self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'blockdev')
        size = self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'size')
        self.part = partition.Partition(self.disk)
        self.part.mkfs(fstype='xfs',
                       args='-b size=%s -s size=512 %s' %
                       (memory.get_page_size(), self.reflink))
        mnt_path = self.params.get('mnt_point', default='/pmem')
        if not os.path.exists(mnt_path):
            os.makedirs(mnt_path)
        self.part.mount(mountpoint=mnt_path, args='-o dax')
        self.log.info("Test will run on %s", mnt_path)
        fio_job = self.params.get('fio_job', default='ndctl-fio.job')
        cmd = '%s --directory %s --filename mmap-pmem --size %s %s' % (
            self.build_fio(), mnt_path, size // 2, self.get_data(fio_job))
        if process.system(cmd, ignore_status=True):
            self.fail("FIO mmap workload on fsdax failed")

    @avocado.fail_on(pmem.PMemException)
    def test_map_sync(self):
        """
        Test MAP_SYNC flag with sample mmap write
        """
        region = self.get_default_region()
        self.plib.create_namespace(region=region, mode='fsdax')
        self.disk = '/dev/%s' % self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'blockdev')
        self.part = partition.Partition(self.disk)
        self.part.mkfs(fstype='xfs',
                       args='-b size=%s -s size=512 %s' %
                       (memory.get_page_size(), self.reflink))
        mnt_path = self.params.get('mnt_point', default='/pmem_map')
        if not os.path.exists(mnt_path):
            os.makedirs(mnt_path)
        self.part.mount(mountpoint=mnt_path, args='-o dax')
        self.log.info("Testing MAP_SYNC on %s", mnt_path)
        src_file = os.path.join(self.teststmpdir, 'map_sync.c')
        shutil.copyfile(self.get_data('map_sync.c'), src_file)
        process.system('gcc %s -o map_sync' % src_file)
        process.system('fallocate -l 64k %s/new_file' % mnt_path)
        if process.system('./map_sync %s/new_file' % mnt_path,
                          ignore_status=True):
            self.fail('Write with MAP_SYNC flag failed')

    @avocado.fail_on(pmem.PMemException)
    def test_devdax_write(self):
        """
        Test device DAX with a daxio binary
        """
        region = self.get_default_region()
        self.plib.create_namespace(region=region, mode='devdax')
        daxdev = "/dev/%s" % self.plib.run_ndctl_list_val(
            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'chardev')
        if process.system("%s -b no -i /dev/urandom -o %s" %
                          (self.get_data("daxio.static"), daxdev),
                          ignore_status=True):
            self.fail("DAXIO write on devdax failed")

    @avocado.fail_on(pmem.PMemException)
    def tearDown(self):
        if self.part:
            self.part.unmount()
        if self.disk:
            self.log.info("Removing the FS meta created on %s", self.disk)
            delete_fs = "dd if=/dev/zero bs=1M count=1024 of=%s" % self.disk
            if process.system(delete_fs, shell=True, ignore_status=True):
                self.fail("Failed to delete filesystem on %s" % self.disk)

        if not self.preserve_setup:
            if self.plib.run_ndctl_list('-N'):
                self.plib.destroy_namespace(force=True)
            self.plib.disable_region()
Beispiel #45
0
    def setUp(self):
        """
        Setup and install dependencies for the test.
        """
        self.test_name = "ucmatose"
        self.basic = self.params.get("basic_option", default="None")
        self.ext = self.params.get("ext_option", default="None")
        self.flag = self.params.get("ext_flag", default="0")
        if self.basic == "None" and self.ext == "None":
            self.cancel("No option given")
        if self.flag == "1" and self.ext != "None":
            self.option = self.ext
        else:
            self.option = self.basic
        if process.system("ibstat", shell=True, ignore_status=True) != 0:
            self.cancel("MOFED is not installed. Skipping")
        detected_distro = distro.detect()
        pkgs = []
        smm = SoftwareManager()
        if detected_distro.name == "Ubuntu":
            pkgs.extend(["openssh-client", "iputils-ping"])
        elif detected_distro.name == "SuSE":
            pkgs.extend(["openssh", "iputils"])
        else:
            pkgs.extend(["openssh-clients", "iputils"])
        for pkg in pkgs:
            if not smm.check_installed(pkg) and not smm.install(pkg):
                self.cancel("Not able to install %s" % pkg)
        interfaces = netifaces.interfaces()
        self.flag = self.params.get("ext_flag", default="0")
        self.iface = self.params.get("interface", default="")
        self.peer_ip = self.params.get("peer_ip", default="")
        self.peer_user = self.params.get("peer_user_name", default="root")
        self.peer_password = self.params.get("peer_password", '*',
                                             default="passw0rd")
        self.peer_login(self.peer_ip, self.peer_user, self.peer_password)
        if self.iface not in interfaces:
            self.cancel("%s interface is not available" % self.iface)
        if self.peer_ip == "":
            self.cancel("%s peer machine is not available" % self.peer_ip)
        self.timeout = "2m"
        self.local_ip = netifaces.ifaddresses(self.iface)[AF_INET][0]['addr']

        if detected_distro.name == "Ubuntu":
            cmd = "service ufw stop"
        # 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', 'fedora', 'redhat']:
            cmd = "systemctl stop firewalld"
        elif detected_distro.name == "SuSE":
            if detected_distro.version == 15:
                cmd = "systemctl stop firewalld"
            else:
                cmd = "rcSuSEfirewall2 stop"
        elif detected_distro.name == "centos":
            cmd = "service iptables stop"
        else:
            self.cancel("Distro not supported")
        if process.system(cmd, ignore_status=True, shell=True) != 0:
            self.cancel("Unable to disable firewall")
        output, exitcode = self.run_command(cmd)
        if exitcode != 0:
            self.cancel("Unable to disable firewall on peer")
Beispiel #46
0
 def setUp(self):
     '''
     To check and install dependencies for the test
     '''
     detected_distro = distro.detect()
     smm = SoftwareManager()
     depends = []
     # 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 detected_distro.name == "Ubuntu":
         depends.extend(["openssh-client", "iputils-ping"])
     elif detected_distro.name in ["rhel", "fedora", "centos", "redhat"]:
         depends.extend(["openssh-clients", "iputils"])
     else:
         depends.extend(["openssh", "iputils"])
     for pkg in depends:
         if not smm.check_installed(pkg) and not smm.install(pkg):
             self.cancel("%s package is need to test" % pkg)
     self.mode = self.params.get("bonding_mode", default="")
     if 'setup' in str(self.name) or 'run' in str(self.name):
         if not self.mode:
             self.cancel("test skipped because mode not specified")
     interfaces = netifaces.interfaces()
     self.peer_public_ip = self.params.get("peer_public_ip", default="")
     self.user = self.params.get("user_name", default="root")
     self.password = self.params.get("peer_password", '*', default="None")
     self.host_interfaces = self.params.get("bond_interfaces",
                                            default="").split(" ")
     if not self.host_interfaces:
         self.cancel("user should specify host interfaces")
     self.peer_interfaces = self.params.get("peer_interfaces",
                                            default="").split(" ")
     for self.host_interface in self.host_interfaces:
         if self.host_interface not in interfaces:
             self.cancel("interface is not available")
     self.peer_first_ipinterface = self.params.get("peer_ip", default="")
     if not self.peer_interfaces or self.peer_first_ipinterface == "":
         self.cancel("peer machine should available")
     self.ipaddr = self.params.get("host_ips", default="").split(" ")
     self.netmask = self.params.get("netmask", default="")
     self.localhost = LocalHost()
     if 'setup' in str(self.name.name):
         for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
             networkinterface = NetworkInterface(interface, self.localhost)
             try:
                 networkinterface.add_ipaddr(ipaddr, self.netmask)
                 networkinterface.save(ipaddr, self.netmask)
             except Exception:
                 networkinterface.save(ipaddr, self.netmask)
             networkinterface.bring_up()
     self.miimon = self.params.get("miimon", default="100")
     self.fail_over_mac = self.params.get("fail_over_mac", default="2")
     self.downdelay = self.params.get("downdelay", default="0")
     self.bond_name = self.params.get("bond_name", default="tempbond")
     self.net_path = "/sys/class/net/"
     self.bond_status = "/proc/net/bonding/%s" % self.bond_name
     self.bond_dir = os.path.join(self.net_path, self.bond_name)
     self.bonding_slave_file = "%s/bonding/slaves" % self.bond_dir
     self.bonding_masters_file = "%s/bonding_masters" % self.net_path
     self.peer_bond_needed = self.params.get("peer_bond_needed",
                                             default=False)
     self.peer_wait_time = self.params.get("peer_wait_time", default=5)
     self.sleep_time = int(self.params.get("sleep_time", default=5))
     self.mtu = self.params.get("mtu", default=1500)
     self.ib = False
     if self.host_interface[0:2] == 'ib':
         self.ib = True
     self.log.info("Bond Test on IB Interface? = %s", self.ib)
     self.session = Session(self.peer_first_ipinterface,
                            user=self.user,
                            password=self.password)
     self.setup_ip()
     self.err = []
     self.remotehost = RemoteHost(self.peer_first_ipinterface,
                                  self.user,
                                  password=self.password)
     self.remotehost_public = RemoteHost(self.peer_public_ip,
                                         self.user,
                                         password=self.password)
     if 'setup' in str(self.name.name):
         for interface in self.peer_interfaces:
             peer_networkinterface = NetworkInterface(
                 interface, self.remotehost)
             if peer_networkinterface.set_mtu(self.mtu) is not None:
                 self.cancel("Failed to set mtu in peer")
         for host_interface in self.host_interfaces:
             self.networkinterface = NetworkInterface(
                 host_interface, self.localhost)
             if self.networkinterface.set_mtu(self.mtu) is not None:
                 self.cancel("Failed to set mtu in host")
    def setUp(self):
        '''
        To check and install dependencies for the test
        '''
        smm = SoftwareManager()
        detected_distro = distro.detect()
        pkgs = ["gcc"]
        if detected_distro.name == "Ubuntu":
            pkgs.append('openssh-client')
        elif detected_distro.name == "SuSE":
            pkgs.append('openssh')
        else:
            pkgs.append('openssh-clients')
        for pkg in pkgs:
            if not smm.check_installed(pkg) and not smm.install(pkg):
                self.cancel("%s package is need to test" % pkg)
        interfaces = netifaces.interfaces()
        self.iface = self.params.get("interface", default="")
        self.peer_ip = self.params.get("peer_ip", default="")
        if self.iface not in interfaces:
            self.cancel("%s interface is not available" % self.iface)
        if self.peer_ip == "":
            self.cancel("%s peer machine is not available" % self.peer_ip)
        self.tmo = self.params.get("TIMEOUT", default="600")
        self.iperf_run = self.params.get("IPERF_RUN", default="0")
        self.netserver_run = self.params.get("NETSERVER_RUN", default="0")
        self.iper = os.path.join(self.teststmpdir, 'iperf')
        self.netperf = os.path.join(self.teststmpdir, 'netperf')
        if detected_distro.name == "Ubuntu":
            cmd = "service ufw stop"
        # 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', 'fedora', 'redhat']:
            cmd = "systemctl stop firewalld"
        elif detected_distro.name == "SuSE":
            cmd = "rcSuSEfirewall2 stop"
        elif detected_distro.name == "centos":
            cmd = "service iptables stop"
        else:
            self.cancel("Distro not supported")
        if process.system("%s && ssh %s %s" % (cmd, self.peer_ip, cmd),
                          ignore_status=True,
                          shell=True) != 0:
            self.cancel("Unable to disable firewall")

        tarball = self.fetch_asset(
            'ftp://ftp.netperf.org/netperf/'
            'netperf-2.7.0.tar.bz2',
            expire='7d')
        archive.extract(tarball, self.netperf)
        version = os.path.basename(tarball.split('.tar.')[0])
        self.neperf = os.path.join(self.netperf, version)
        tmp = "scp -r %s root@%s:" % (self.neperf, self.peer_ip)
        if process.system(tmp, shell=True, ignore_status=True) != 0:
            self.cancel("unable to copy the netperf into peer machine")
        tmp = "cd /root/netperf-2.7.0;./configure ppc64le;make"
        cmd = "ssh %s \"%s\"" % (self.peer_ip, tmp)
        if process.system(cmd, shell=True, ignore_status=True) != 0:
            self.fail("test failed because command failed in peer machine")
        time.sleep(5)
        os.chdir(self.neperf)
        process.system('./configure ppc64le', shell=True)
        build.make(self.neperf)
        self.perf = os.path.join(self.neperf, 'src')
        time.sleep(5)
        tarball = self.fetch_asset(
            'iperf.zip',
            locations=['https://github.com/esnet/iperf/archive/master.zip'],
            expire='7d')
        archive.extract(tarball, self.iper)
        self.ipe = os.path.join(self.iper, 'iperf-master')
        tmp = "scp -r %s root@%s:" % (self.ipe, self.peer_ip)
        if process.system(tmp, shell=True, ignore_status=True) != 0:
            self.cancel("unable to copy the iperf into peer machine")
        tmp = "cd /root/iperf-master;./configure;make"
        cmd = "ssh %s \"%s\"" % (self.peer_ip, tmp)
        if process.system(cmd, shell=True, ignore_status=True) != 0:
            self.fail("test failed because command failed in peer machine")
        time.sleep(5)
        os.chdir(self.ipe)
        process.system('./configure', shell=True)
        build.make(self.ipe)
        self.iperf = os.path.join(self.ipe, 'src')
Beispiel #48
0
    def setUp(self):
        '''
        To check and install dependencies for the test
        '''
        interfaces = netifaces.interfaces()
        self.flag = self.params.get("ext_flag", default="0")
        self.iface = self.params.get("interface", default="")
        self.peer_ip = self.params.get("peer_ip", default="")
        if self.iface not in interfaces:
            self.cancel("%s interface is not available" % self.iface)
        if self.peer_ip == "":
            self.cancel("%s peer machine is not available" % self.peer_ip)
        self.ca_name = self.params.get("CA_NAME", default="mlx4_0")
        self.gid = int(self.params.get("GID_NUM", default="0"))
        self.port = int(self.params.get("PORT_NUM", default="1"))
        self.peer_ca = self.params.get("PEERCA", default="mlx4_0")
        self.peer_gid = int(self.params.get("PEERGID", default="0"))
        self.peer_port = int(self.params.get("PEERPORT", default="1"))
        self.tmo = self.params.get("TIMEOUT", default="120")

        smm = SoftwareManager()
        detected_distro = distro.detect()
        pkgs = []
        if detected_distro.name == "Ubuntu":
            pkgs.extend(["ibverbs-utils", 'openssh-client'])
            cmd = "service ufw stop"
        # 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', 'fedora', 'redhat']:
            pkgs.extend(["libibverbs", 'openssh-clients'])
            cmd = "systemctl stop firewalld"
        elif detected_distro.name == "SuSE":
            pkgs.append('openssh')
            if detected_distro.version == 15:
                cmd = "systemctl stop firewalld"
            else:
                cmd = "rcSuSEfirewall2 stop"
        elif detected_distro.name == "centos":
            pkgs.extend(['libibverbs', 'openssh-clients'])
            cmd = "service iptables stop"
        else:
            self.cancel("Distro not supported")
        if process.system("%s && ssh %s %s" %
                          (cmd, self.peer_ip, cmd),
                          ignore_status=True,
                          shell=True) != 0:
            self.cancel("Unable to disable firewall")
        for pkg in pkgs:
            if not smm.check_installed(pkg) and not smm.install(pkg):
                self.cancel("%s package is need to test" % pkg)
        if process.system("ibstat", shell=True, ignore_status=True) != 0:
            self.cancel("infiniband adaptors not available")
        self.tool_name = self.params.get("tool")
        self.log.info("test with %s", self.tool_name)
        self.peer_iface = ''
        cmd = "ssh %s \"ip addr show\"" % self.peer_ip
        output = process.system_output(cmd, shell=True).strip()
        for line in output.splitlines():
            if self.peer_ip in line:
                self.peer_iface = line.split()[-1]
                break
Beispiel #49
0
    def setUp(self):
        '''
        Build lmbench
        Source:
        http://www.bitmover.com/lmbench/lmbench3.tar.gz
        '''
        fsdir = self.params.get('fsdir', default=None)
        temp_file = self.params.get('temp_file', default=None)
        memory_size_mb = self.params.get('MB', default=125)
        self.tmpdir = tempfile.mkdtemp(prefix='avocado_' + __name__)
        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.bitmover.com'
                                   '/lmbench/lmbench3.tar.gz')
        archive.extract(tarball, self.workdir)
        version = os.path.basename(tarball.split('.tar.')[0])
        self.sourcedir = os.path.join(self.workdir, version)

        # Patch for lmbench

        os.chdir(self.sourcedir)

        makefile_patch = 'patch -p1 < %s' % self.get_data('makefile.patch')
        build_patch = 'patch -p1 < %s' % self.get_data(
            '0001-Fix-build-issues-with-lmbench.patch')
        lmbench_fix_patch = 'patch -p1 < %s' % self.get_data(
            '0002-Changing-shebangs-on-lmbench-scripts.patch')
        ostype_fix_patch = 'patch -p1 < %s' % self.get_data(
            'fix_add_os_type.patch')

        process.run(makefile_patch, shell=True)
        process.run(build_patch, shell=True)
        process.run(lmbench_fix_patch, shell=True)
        process.run(ostype_fix_patch, shell=True)

        build.make(self.sourcedir)

        # configure lmbench
        os.chdir(self.sourcedir)

        process.system('yes "" | make config', shell=True, ignore_status=True)

        # find the lmbench config file
        output = os.popen('ls -1 bin/*/CONFIG*').read()
        config_files = output.splitlines()
        if len(config_files) != 1:
            self.error('Config not found : % s' % config_files)
        config_file = config_files[0]
        if not fsdir:
            fsdir = self.tmpdir
        if not temp_file:
            temp_file = os.path.join(self.tmpdir, 'XXX')

        # patch the resulted config to use the proper temporary directory and
        # file locations
        with open(config_file, "r+") as cfg_file:
            lines = cfg_file.readlines()
            cfg_file.seek(0)
            cfg_file.truncate()
            for line in lines:
                if line.startswith("FSDIR="):
                    cfg_file.write("FSDIR=%s\n" % fsdir)
                elif line.startswith("FILE="):
                    cfg_file.write("FILE=%s\n" % temp_file)
                elif line.startswith("MB="):
                    cfg_file.write("MB=%s\n" % memory_size_mb)
                else:
                    cfg_file.write(line)
            # Printing the config file
            cfg_file.seek(0)
            for line in cfg_file.readlines():
                print(line)
Beispiel #50
0
    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.
        """

        smm = SoftwareManager()
        dist = distro.detect()
        dist_name = dist.name.lower()

        packages = [
            'gcc', 'wget', 'autoconf', 'automake', 'dejagnu', 'binutils',
            'patch'
        ]

        if dist_name == 'suse':
            packages.extend([
                'libdw-devel', 'libelf-devel', 'git-core', 'elfutils',
                'binutils-devel', 'libtool', 'gcc-c++'
            ])

        # 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", "fedora", "redhat"):
            packages.extend([
                'elfutils-devel', 'elfutils-libelf-devel', 'git',
                'elfutils-libelf', 'elfutils-libs', 'libtool-ltdl'
            ])

        elif dist_name == 'ubuntu':
            packages.extend([
                'elfutils', 'libelf-dev', 'libtool', 'git', 'libelf1',
                'librpmbuild3', 'binutils-dev'
            ])
        else:
            self.cancel("Unsupported OS!")

        for package in packages:
            if not smm.check_installed(package) and not smm.install(package):
                self.cancel("Fail to install %s required for this test." %
                            package)
        run_type = self.params.get("type", default="upstream")
        if run_type == "upstream":
            source = self.params.get('url',
                                     default="https://gitlab.com/"
                                     "cespedes/ltrace.git")
            git.get_repo(source,
                         destination_dir=os.path.join(self.workdir, 'ltrace'))

            self.src_lt = os.path.join(self.workdir, "ltrace")
            os.chdir(self.src_lt)
            process.run('patch -p1 < %s' % self.get_data('ltrace.patch'),
                        shell=True)
        elif run_type == "distro":
            self.src_lt = os.path.join(self.workdir, "ltrace-distro")
            if not os.path.exists(self.src_lt):
                self.src_lt = smm.get_source("ltrace", self.src_lt)
            os.chdir(self.src_lt)

        process.run('./autogen.sh')
        process.run('./configure')
        build.make(self.src_lt)
Beispiel #51
0
    def setUp(self):
        """
        Resolve the packages dependencies and download the source.
        """
        smg = SoftwareManager()
        self.comp = self.params.get('comp', default='')
        run_type = self.params.get('type', default='upstream')
        if self.comp:
            self.comp = '-C %s' % self.comp
        detected_distro = distro.detect()
        deps = ['gcc', 'make', 'automake', 'autoconf']

        if 'Ubuntu' in detected_distro.name:
            deps.extend(['libpopt0', 'libc6', 'libc6-dev', 'libcap-dev',
                         'libpopt-dev', 'libcap-ng0', 'libcap-ng-dev',
                         'libnuma-dev', 'libfuse-dev', 'elfutils', 'libelf1'])
        elif 'SuSE' in detected_distro.name:
            deps.extend(['popt', 'glibc', 'glibc-devel', 'popt-devel', 'sudo',
                         'libcap2', 'libcap-devel', 'libcap-ng-devel',
                         'fuse', 'fuse-devel', 'glibc-devel-static'])
        # 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 ['centos', 'fedora', 'rhel', 'redhat']:
            deps.extend(['popt', 'glibc', 'glibc-devel', 'glibc-static',
                         'libcap-ng', 'libcap', 'libcap-devel', 'fuse-devel',
                         'libcap-ng-devel'])

        for package in deps:
            if not smg.check_installed(package) and not smg.install(package):
                self.cancel(
                    "Fail to install %s required for this test." % (package))

        if run_type == 'upstream':
            location = ["https://github.com/torvalds/linux/archive/master.zip"]
            tarball = self.fetch_asset("kselftest.zip", locations=location,
                                       expire='1d')
            archive.extract(tarball, self.workdir)
            self.buldir = os.path.join(self.workdir, 'linux-master')
        else:
            # Make sure kernel source repo is configured
            if detected_distro.name in ['centos', 'fedora', 'rhel']:
                self.buldir = smg.get_source('kernel', self.workdir)
                self.buldir = os.path.join(
                    self.buldir, os.listdir(self.buldir)[0])
            elif 'Ubuntu' in detected_distro.name:
                self.buldir = smg.get_source('linux', self.workdir)
            elif 'SuSE' in detected_distro.name:
                smg.get_source('kernel-source', self.workdir)
                packages = '/usr/src/packages/'
                os.chdir(os.path.join(packages, 'SOURCES'))
                process.system('./mkspec', ignore_status=True)
                shutil.copy(os.path.join(packages, 'SOURCES/kernel'
                                                   '-default.spec'),
                            os.path.join(packages, 'SPECS/kernel'
                                                   '-default.spec'))
                self.buldir = smg.prepare_source(os.path.join(
                    packages, 'SPECS/kernel'
                              '-default.spec'), dest_path=self.teststmpdir)
                for l_dir in glob.glob(os.path.join(self.buldir, 'linux*')):
                    if os.path.isdir(l_dir) and 'Makefile' in os.listdir(l_dir):
                        self.buldir = os.path.join(
                            self.buldir, os.listdir(self.buldir)[0])

        self.sourcedir = os.path.join(self.buldir, self.testdir)
        result = build.run_make(self.sourcedir)
        for line in str(result).splitlines():
            if 'ERROR' in line:
                self.fail("Compilation failed, Please check the build logs !!")
Beispiel #52
0
    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.lower() == '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'
            ])
            if (int(dist.version) == 15 and int(dist.release) > 3):
                packages.remove('isl-devel')
        else:
            packages.extend([
                'glibc-static', 'elfutils-devel', 'texinfo-tex', 'texinfo',
                'elfutils-libelf-devel', 'gmp-devel', 'mpfr-devel',
                'libmpc-devel', 'zlib-devel', 'gettext', 'libgcc', 'libgomp',
                'dblatex', 'doxygen', 'texlive-collection-latex',
                'python3-sphinx', 'systemtap-sdt-devel'
            ])
        if dist.name == 'rhel' and \
           (int(dist.version) == 8 and int(dist.release) >= 6):
            packages.extend([
                'autogen', 'guile', 'guile-devel', 'isl-devel',
                'docbook5-style-xsl'
            ])

        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)
        run_type = self.params.get('type', default='distro')
        if run_type == "upstream":
            url = 'https://github.com/gcc-mirror/gcc/archive/master.zip'
            tarball = self.fetch_asset('gcc.zip', locations=[url], expire='7d')
            archive.extract(tarball, self.workdir)
            self.sourcedir = os.path.join(self.workdir, 'gcc-master')
        elif run_type == "distro":
            self.sourcedir = os.path.join(self.workdir, 'gcc-distro')
            if not os.path.exists(self.sourcedir):
                os.makedirs(self.sourcedir)
            """
            FIXME. On certain distros I have observed get_source()
            API fails to populate source tree. This can be an
            avocado utils issue. Explicitly fail this testcase
            until it has been root caused.
            """
            if (int(dist.version) == 15 and int(dist.release) > 3):
                self.fail('Test case is broken for this release')
            else:
                self.sourcedir = smm.get_source("gcc", self.sourcedir)
        os.chdir(self.sourcedir)
        process.run('./configure', ignore_status=True, sudo=True)
        build.make(self.sourcedir, ignore_status=True)
Beispiel #53
0
    def setUp(self):
        """
        Set up.
        """
        self.policy = self.params.get('policy', default='service-time')
        self.policies = ["service-time", "round-robin", "queue-length"]
        # We will remove and add the policy back, so that this becomes
        # the last member of the list. This is done so that in the
        # policy change test later, this policy is set in the last
        # iteration.
        self.policies.remove(self.policy)
        self.policies.append(self.policy)
        self.op_shot_sleep_time = 60
        self.op_long_sleep_time = 180
        # Install needed packages
        dist = distro.detect()
        pkg_name = ""
        svc_name = ""
        if dist.name in ['Ubuntu', 'debian']:
            pkg_name += "multipath-tools"
            svc_name = "multipath-tools"
        elif dist.name == 'SuSE':
            pkg_name += "multipath-tools"
            svc_name = "multipathd"
        else:
            pkg_name += "device-mapper-multipath"
            svc_name = "multipathd"

        smm = SoftwareManager()
        if not smm.check_installed(pkg_name) and not smm.install(pkg_name):
            self.cancel("Can not install %s" % pkg_name)

        # Check if given multipath devices are present in system
        self.wwids = self.params.get('wwids', default='').split(',')
        system_wwids = multipath.get_multipath_wwids()
        wwids_to_remove = []
        for wwid in self.wwids:
            if wwid not in system_wwids:
                self.log.info("%s not present in the system", wwid)
                wwids_to_remove.append(wwid)
        for wwid in wwids_to_remove:
            self.wwids.remove(wwid)
        if self.wwids == ['']:
            self.cancel("No Multipath Devices Given")

        # Create service object
        self.mpath_svc = service.SpecificServiceManager(svc_name)
        self.mpath_svc.restart()
        wait.wait_for(self.mpath_svc.status, timeout=10)

        # Take a backup of current config file
        self.mpath_file = "/etc/multipath.conf"
        if os.path.isfile(self.mpath_file):
            shutil.copyfile(self.mpath_file, "%s.bkp" % self.mpath_file)

        self.mpath_list = []

        # Find all details of multipath devices
        for wwid in self.wwids:
            if wwid not in process.system_output('multipath -ll',
                                                 ignore_status=True,
                                                 shell=True).decode('utf-8'):
                continue
            self.mpath_dic = {}
            self.mpath_dic["wwid"] = wwid
            self.mpath_dic["name"] = multipath.get_mpath_name(wwid)
            self.mpath_dic["paths"] = multipath.get_paths(wwid)
            self.mpath_dic["policy"] = multipath.get_policy(wwid)
            self.mpath_dic["size"] = multipath.get_size(wwid)
            self.mpath_list.append(self.mpath_dic)
        pprint(self.mpath_list)
Beispiel #54
0
    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
        """
        fstype = self.params.get('fs', default='ext4')

        smm = SoftwareManager()
        # Install the package from web
        deps = ['gcc', 'make']
        if distro.detect().name == 'Ubuntu':
            deps.extend(['g++'])
        else:
            deps.extend(['gcc-c++'])
        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 not supported with RHEL 7.4 onwards")
            elif distro.detect().name == 'Ubuntu':
                deps.extend(['btrfs-tools'])

        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')

        self.disk = self.params.get('disk', default=None)
        self.scratch_dir = self.params.get('dir', default=self.workdir)
        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)

        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)
            try:
                self.part_obj.mount()
            except PartitionError:
                self.fail("Mounting disk %s on directory %s failed" %
                          (self.disk, self.scratch_dir))
Beispiel #55
0
def run(test, params, env):
    """
    Test different hmi injections with guest

    :param test: QEMU test object
    :param params: Dictionary with the test parameters
    :param env: Dictionary with test environment.
    """
    def set_condn(action, recover=False):
        """
        Set/reset guest state/action
        :param action: Guest state change/action
        :param recover: whether to recover given state default: False
        """
        if not recover:
            if action == "pin_vcpu":
                for i in range(cur_vcpu):
                    virsh.vcpupin(vm_name,
                                  i,
                                  hmi_cpu,
                                  "--live",
                                  ignore_status=False,
                                  debug=True)
                    virsh.emulatorpin(vm_name,
                                      hmi_cpu,
                                      "live",
                                      ignore_status=False,
                                      debug=True)
            elif action == "filetrans":
                utils_test.run_file_transfer(test, params, env)
            elif action == "save":
                save_file = os.path.join(data_dir.get_tmp_dir(),
                                         vm_name + ".save")
                result = virsh.save(vm_name,
                                    save_file,
                                    ignore_status=True,
                                    debug=True)
                utils_test.libvirt.check_exit_status(result)
                time.sleep(10)
                if os.path.exists(save_file):
                    result = virsh.restore(save_file,
                                           ignore_status=True,
                                           debug=True)
                    utils_test.libvirt.check_exit_status(result)
                    os.remove(save_file)
            elif action == "suspend":
                result = virsh.suspend(vm_name, ignore_status=True, debug=True)
                utils_test.libvirt.check_exit_status(result)
                time.sleep(10)
                result = virsh.resume(vm_name, ignore_status=True, debug=True)
                utils_test.libvirt.check_exit_status(result)
        return

    host_version = params.get("host_version")
    guest_version = params.get("guest_version", "")
    max_vcpu = int(params.get("ppchmi_vcpu_max", '1'))
    cur_vcpu = int(params.get("ppchmi_vcpu_cur", "1"))
    cores = int(params.get("ppchmi_cores", '1'))
    sockets = int(params.get("ppchmi_sockets", '1'))
    threads = int(params.get("ppchmi_threads", '1'))
    status_error = "yes" == params.get("status_error", "no")
    condition = params.get("condn", "")
    inject_code = params.get("inject_code", "")
    scom_base = params.get("scom_base", "")
    hmi_name = params.get("hmi_name", "")
    hmi_iterations = int(params.get("hmi_iterations", 1))

    if host_version not in cpu.get_cpu_arch():
        test.cancel("Unsupported Host cpu version")

    vm_name = params.get("main_vm")
    vm = env.get_vm(vm_name)
    sm = SoftwareManager()
    if not sm.check_installed("opal-utils") and not sm.install("opal-utils"):
        test.cancel("opal-utils package install failed")
    cpus_list = cpu.cpu_online_list()
    cpu_idle_state = cpu.get_cpuidle_state()
    cpu.set_cpuidle_state()
    # Lets use second available host cpu
    hmi_cpu = cpus_list[1]
    pir = int(
        open('/sys/devices/system/cpu/cpu%s/pir' % hmi_cpu).read().strip(), 16)
    if host_version == 'power9':
        coreid = (((pir) >> 2) & 0x3f)
        nodeid = (((pir) >> 8) & 0x7f) & 0xf
        hmi_scom_addr = hex(((coreid & 0x1f + 0x20) << 24)
                            | int(scom_base, 16))
    if host_version == 'power8':
        coreid = (((pir) >> 3) & 0xf)
        nodeid = (((pir) >> 7) & 0x3f)
        hmi_scom_addr = hex(((coreid & 0xf) << 24) | int(scom_base, 16))
    hmi_cmd = "putscom -c %s %s %s" % (nodeid, hmi_scom_addr, inject_code)

    vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
    org_xml = vmxml.copy()
    # Destroy the vm
    vm.destroy()
    try:
        session = None
        bgt = None
        libvirt_xml.VMXML.set_vm_vcpus(vm_name,
                                       max_vcpu,
                                       cur_vcpu,
                                       sockets=sockets,
                                       cores=cores,
                                       threads=threads,
                                       add_topology=True)
        if guest_version:
            libvirt_xml.VMXML.set_cpu_mode(vm_name, model=guest_version)
        vm.start()
        # Lets clear host and guest dmesg
        process.system("dmesg -C", verbose=False)
        session = vm.wait_for_login()
        session.cmd("dmesg -C")

        # Set condn
        if "vcpupin" in condition:
            set_condn("pin_vcpu")
        if "stress" in condition:
            utils_test.load_stress("stress_in_vms", params=params, vms=[vm])
        if "save" in condition:
            set_condn("save")
        if "suspend" in condition:
            set_condn("suspend")

        # hmi inject
        logging.debug("Injecting %s HMI on cpu %s", hmi_name, hmi_cpu)
        logging.debug("HMI Command: %s", hmi_cmd)
        process.run(hmi_cmd)

        # Check host and guest dmesg
        host_dmesg = process.run("dmesg -c", verbose=False).stdout_text
        guest_dmesg = session.cmd_output("dmesg")
        if "Unrecovered" in host_dmesg:
            test.fail("Unrecovered host hmi\n%s", host_dmesg)
        else:
            logging.debug("Host dmesg: %s", host_dmesg)
        logging.debug("Guest dmesg: %s", guest_dmesg)
        if "save" in condition:
            set_condn("save")
        if "suspend" in condition:
            set_condn("suspend")
    finally:
        if "stress" in condition:
            utils_test.unload_stress("stress_in_vms", params=params, vms=[vm])
        if session:
            session.close()
        org_xml.sync()
        cpu.set_cpuidle_state(setstate=cpu_idle_state)
Beispiel #56
0
    def setUp(self):
        # 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
        sm = SoftwareManager()
        detected_distro = distro.detect()
        deps = ['gcc', 'make', 'patch']

        if detected_distro.name == "Ubuntu":
            deps += ['libpthread-stubs0-dev', 'git']
        elif detected_distro.name == "SuSE":
            deps += ['glibc-devel-static', 'git-core']
        else:
            deps += ['glibc-static', 'git']

        for package in deps:
            if not sm.check_installed(package) and not sm.install(package):
                self.cancel(' %s is needed for the test to be run' % package)

        kernel.check_version("2.6.16")

        if detected_distro.name == "Ubuntu":
            op = glob.glob("/usr/lib/*/libpthread.a")
        else:
            op = glob.glob("/usr/lib*/libpthread.a")

        if not op:
            self.error("libpthread.a is required!!!"
                       "\nTry installing glibc-static")

        # Get arguments:
        self.hugetlbfs_dir = self.params.get('hugetlbfs_dir', default=None)
        pages_requested = self.params.get('pages_requested', default=20)

        # Check hugepages:
        pages_available = 0
        if os.path.exists('/proc/sys/vm/nr_hugepages'):
            Hugepages_support = process.system_output('cat /proc/meminfo',
                                                      verbose=False,
                                                      shell=True)
            if 'HugePages_' not in Hugepages_support:
                self.error("No Hugepages Configured")
            memory.set_num_huge_pages(pages_requested)
            pages_available = memory.get_num_huge_pages()
        else:
            self.error("Kernel does not support hugepages")

        # Check no of hugepages :
        if pages_available < pages_requested:
            self.error(
                '%d pages available, < %d pages requested' % pages_available,
                pages_requested)

        # Check if hugetlbfs is mounted
        cmd_result = process.run('grep hugetlbfs /proc/mounts', verbose=False)
        if not cmd_result:
            if not self.hugetlbfs_dir:
                self.hugetlbfs_dir = os.path.join(self.tmpdir, 'hugetlbfs')
                os.makedirs(self.hugetlbfs_dir)
            process.system('mount -t hugetlbfs none %s' % self.hugetlbfs_dir)

        data_dir = os.path.abspath(self.datadir)
        git.get_repo('https://github.com/libhugetlbfs/libhugetlbfs.git',
                     destination_dir=self.srcdir)
        os.chdir(self.srcdir)
        patch = self.params.get('patch', default='elflink.patch')
        process.run('patch -p1 < %s' % data_dir + '/' + patch, shell=True)

        # 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 detected_distro.name in ["rhel", "fedora", "redhat"]:
            falloc_patch = 'patch -p1 < %s ' % (os.path.join(
                data_dir, 'falloc.patch'))
            process.run(falloc_patch, shell=True)

        build.make(self.srcdir, extra_args='BUILDTYPE=NATIVEONLY')
Beispiel #57
0
 def setUp(self):
     sm = SoftwareManager()
     for package in ("ppc64-diag", "powerpc-utils", "lsvpd", "ipmitool"):
         if not sm.check_installed(package) and not sm.install(package):
             self.cancel("Fail to install %s required for this test." %
                         package)
 def setUp(self):
     """
     To check and install dependencies for the test
     """
     self.peer_user = self.params.get("peer_user", default="root")
     self.peer_public_ip = self.params.get("peer_public_ip", default="")
     self.peer_ip = self.params.get("peer_ip", default="")
     self.peer_password = self.params.get("peer_password", '*',
                                          default="None")
     interfaces = netifaces.interfaces()
     self.iface = self.params.get("interface", default="")
     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="")
     local = LocalHost()
     self.networkinterface = NetworkInterface(self.iface, local)
     try:
         self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
         self.networkinterface.save(self.ipaddr, self.netmask)
     except Exception:
         self.networkinterface.save(self.ipaddr, self.netmask)
     self.networkinterface.bring_up()
     self.session = Session(self.peer_ip, user=self.peer_user,
                            password=self.peer_password)
     if not self.session.connect():
         self.cancel("failed connecting to peer")
     smm = SoftwareManager()
     detected_distro = distro.detect()
     pkgs = ['gcc']
     if detected_distro.name == "Ubuntu":
         pkgs.append('openssh-client')
     elif detected_distro.name == "SuSE":
         pkgs.append('openssh')
     else:
         pkgs.append('openssh-clients')
     for pkg in pkgs:
         if not smm.check_installed(pkg) and not smm.install(pkg):
             self.cancel("%s package is need to test" % pkg)
         cmd = "%s install %s" % (smm.backend.base_command, pkg)
         output = self.session.cmd(cmd)
         if not output.exit_status == 0:
             self.cancel("unable to install the package %s on peer machine "
                         % pkg)
     if self.peer_ip == "":
         self.cancel("%s peer machine is not available" % self.peer_ip)
     self.timeout = self.params.get("TIMEOUT", default="600")
     self.mtu = self.params.get("mtu", default=1500)
     self.remotehost = RemoteHost(self.peer_ip, self.peer_user,
                                  password=self.peer_password)
     self.peer_interface = self.remotehost.get_interface_by_ipaddr(self.peer_ip).name
     self.peer_networkinterface = NetworkInterface(self.peer_interface,
                                                   self.remotehost)
     self.remotehost_public = RemoteHost(self.peer_public_ip, self.peer_user,
                                         password=self.peer_password)
     self.peer_public_networkinterface = NetworkInterface(self.peer_interface,
                                                          self.remotehost_public)
     if self.peer_networkinterface.set_mtu(self.mtu) is not None:
         self.cancel("Failed to set mtu in peer")
     if self.networkinterface.set_mtu(self.mtu) is not None:
         self.cancel("Failed to set mtu in host")
     self.netperf_run = str(self.params.get("NETSERVER_RUN", default=0))
     self.netperf = os.path.join(self.teststmpdir, 'netperf')
     netperf_download = self.params.get("netperf_download", default="https:"
                                        "//github.com/HewlettPackard/"
                                        "netperf/archive/netperf-2.7.0.zip")
     tarball = self.fetch_asset(netperf_download, expire='7d')
     archive.extract(tarball, self.netperf)
     self.version = "%s-%s" % ("netperf",
                               os.path.basename(tarball.split('.zip')[0]))
     self.neperf = os.path.join(self.netperf, self.version)
     destination = "%s:/tmp" % self.peer_ip
     output = self.session.copy_files(self.neperf, destination,
                                      recursive=True)
     if not output:
         self.cancel("unable to copy the netperf into peer machine")
     cmd = "cd /tmp/%s;./configure ppc64le;make" % self.version
     output = self.session.cmd(cmd)
     if not output.exit_status == 0:
         self.fail("test failed because command failed in peer machine")
     os.chdir(self.neperf)
     process.system('./configure ppc64le', shell=True)
     build.make(self.neperf)
     self.perf = os.path.join(self.neperf, 'src', 'netperf')
     self.expected_tp = self.params.get("EXPECTED_THROUGHPUT", default="90")
     self.duration = self.params.get("duration", default="300")
     self.min = self.params.get("minimum_iterations", default="1")
     self.max = self.params.get("maximum_iterations", default="15")
     self.option = self.params.get("option", default='')
Beispiel #59
0
    def setUp(self):
        """
        Setup and install dependencies for the test.
        """
        self.test_name = "mckey"
        self.basic = self.params.get("basic_option", default="None")
        self.ext = self.params.get("ext_option", default="None")
        self.flag = self.params.get("ext_flag", default="0")
        if self.basic == "None" and self.ext == "None":
            self.cancel("No option given")
        if self.flag == "1" and self.ext != "None":
            self.option = self.ext
        else:
            self.option = self.basic
        if process.system("ibstat", shell=True, ignore_status=True) != 0:
            self.cancel("MOFED is not installed. Skipping")
        pkgs = []
        detected_distro = distro.detect()
        if detected_distro.name == "Ubuntu":
            pkgs.extend(["openssh-client", "iputils-ping"])
        elif detected_distro.name == "SuSE":
            pkgs.extend(["openssh", "iputils"])
        else:
            pkgs.extend(["openssh-clients", "iputils"])
        smm = SoftwareManager()
        for pkg in pkgs:
            if not smm.check_installed(pkg) and not smm.install(pkg):
                self.cancel("Not able to install %s" % pkg)
        interfaces = netifaces.interfaces()
        self.iface = self.params.get("interface", default="")
        self.peer_ip = self.params.get("peer_ip", default="")
        self.peer_user = self.params.get("peer_user_name", default="root")
        self.peer_password = self.params.get("peer_password",
                                             '*',
                                             default="None")
        self.ipaddr = self.params.get("host_ip", default="")
        self.netmask = self.params.get("netmask", default="")
        if self.iface[0:2] == 'ib':
            configure_network.set_ip(self.ipaddr,
                                     self.netmask,
                                     self.iface,
                                     interface_type='Infiniband')
        else:
            configure_network.set_ip(self.ipaddr,
                                     self.netmask,
                                     self.iface,
                                     interface_type='Ethernet')
        self.session = Session(self.peer_ip,
                               user=self.peer_user,
                               password=self.peer_password)
        if self.iface not in interfaces:
            self.cancel("%s interface is not available" % self.iface)
        if self.peer_ip == "":
            self.cancel("%s peer machine is not available" % self.peer_ip)
        self.timeout = "2m"
        self.local_ip = netifaces.ifaddresses(self.iface)[AF_INET][0]['addr']
        self.ip_val = self.local_ip.split(".")[-1]
        self.mtu = self.params.get("mtu", default=1500)
        self.peerinfo = PeerInfo(self.peer_ip,
                                 peer_user=self.peer_user,
                                 peer_password=self.peer_password)
        self.peer_interface = self.peerinfo.get_peer_interface(self.peer_ip)
        self.option = self.option.replace("PEERIP", self.peer_ip)
        self.option = self.option.replace("LOCALIP", self.local_ip)
        self.option = self.option.replace("IPVAL", self.ip_val)
        self.option_list = self.option.split(",")

        if detected_distro.name == "Ubuntu":
            cmd = "service ufw stop"
        # 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', 'fedora', 'redhat']:
            cmd = "systemctl stop firewalld"
        elif detected_distro.name == "SuSE":
            if detected_distro.version == 15:
                cmd = "systemctl stop firewalld"
            else:
                cmd = "rcSuSEfirewall2 stop"
        elif detected_distro.name == "centos":
            cmd = "service iptables stop"
        else:
            self.cancel("Distro not supported")
        if process.system(cmd, ignore_status=True, shell=True) != 0:
            self.cancel("Unable to disable firewall")
        output = self.session.cmd(cmd)
        if not output.exit_status == 0:
            self.cancel("Unable to disable firewall on peer")
Beispiel #60
0
    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
        """
        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

        smm = SoftwareManager()
        # Install the package from web
        deps = ['gcc', 'make']
        if distro.detect().name == 'Ubuntu':
            deps.extend(['g++'])
        else:
            deps.extend(['gcc-c++'])
        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 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')

        self.disk = self.params.get('disk', default=None)
        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)

        self.scratch_dir = self.disk
        if self.disk is not None:
            if self.disk in disk.get_disks():
                if raid_needed:
                    raid_name = '/dev/md/mdsraid'
                    self.create_raid(self.disk, raid_name)
                    self.raid_create = True
                    self.disk = raid_name
                    self.scratch_dir = self.disk

                if lv_needed:
                    self.disk = self.create_lv(self.disk)
                    self.lv_create = True
                    self.scratch_dir = self.disk

                if fstype:
                    self.scratch_dir = self.workdir
                    self.create_fs(self.disk, self.scratch_dir, fstype)
                    self.fs_create = True