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): ''' 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 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 get_guest_cpuid(self, cpu_model, feature=None, extra_params=None, qom_mode=False): if not qom_mode: test_kernel_dir = os.path.join(data_dir.get_deps_dir(), "cpuid", "src") build.make(test_kernel_dir, extra_args="cpuid_dump_kernel.bin") vm_name = params['main_vm'] params_b = params.copy() if not qom_mode: params_b["kernel"] = os.path.join( test_kernel_dir, "cpuid_dump_kernel.bin") params_b["cpu_model"] = cpu_model params_b["cpu_model_flags"] = feature del params_b["images"] del params_b["nics"] if extra_params: params_b.update(extra_params) env_process.preprocess_vm(self, params_b, env, vm_name) vm = env.get_vm(vm_name) dbg('is dead: %r', vm.is_dead()) vm.create() self.vm = vm if qom_mode: return get_qom_cpuid(self, vm) else: return get_test_kernel_cpuid(self, vm)
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): ''' Build FileBench Source: https://github.com/filebench/filebench/releases/download/1.5-alpha3/filebench-1.5-alpha3.tar.gz ''' # Check for basic utilities smm = SoftwareManager() deps = ['libtool', 'automake', 'autoconf', 'bison', 'gcc', 'flex'] for package in deps: if not smm.check_installed(package) and not smm.install(package): self.error(package + ' is needed for the test to be run') self._testfile = self.params.get('testfile', default='fileserver.f') tarball = self.fetch_asset('https://github.com/filebench/' 'filebench/releases/ownload/1.5-alpha3/' 'filebench-1.5-alpha3.tar.gz', expire='7d') archive.extract(tarball, self.srcdir) version = os.path.basename(tarball.split('.tar.')[0]) self.srcdir = os.path.join(self.srcdir, version) os.chdir(self.srcdir) process.run('./configure', shell=True, sudo=True) build.make(self.srcdir) build.make(self.srcdir, extra_args='install') # Setup test file t_dir = '/usr/local/share/filebench/workloads/' shutil.copyfile(os.path.join(t_dir, self._testfile), os.path.join(self.srcdir, self._testfile))
def setUp(self): """ Build 'nvme-cli' and setup the device. """ self.device = self.params.get('device', default='/dev/nvme0') cmd = 'ls %s' % self.device if process.system(cmd, ignore_status=True) is not 0: self.skip("%s does not exist" % self.device) locations = ["https://github.com/linux-nvme/nvme-cli/archive/" "master.zip"] tarball = self.fetch_asset("nvme-cli.zip", locations=locations, expire='15d') archive.extract(tarball, self.srcdir) os.chdir("%s/nvme-cli-master" % self.srcdir) process.system("./NVME-VERSION-GEN", ignore_status=True) if process.system_output("cat NVME-VERSION-FILE").strip("\n").\ split()[-1] != process.system_output("nvme version").\ strip("\n").split()[-1]: build.make(".") build.make(".", extra_args='install') self.id_ns = self.create_namespace() self.log.info(self.id_ns) cmd = "nvme id-ns %s | grep 'in use' | awk '{print $5}' | \ awk -F':' '{print $NF}'" % self.id_ns self.format_size = process.system_output(cmd, shell=True).strip('\n') self.format_size = pow(2, int(self.format_size)) cmd = "nvme id-ns %s | grep 'in use' | awk '{print $2}'" % self.id_ns self.lba = process.system_output(cmd, shell=True).strip('\n')
def setUp(self): """ fs_mark """ smm = SoftwareManager() tarball = self.fetch_asset('https://github.com/josefbacik/fs_mark/' 'archive/master.zip') archive.extract(tarball, self.teststmpdir) self.sourcedir = os.path.join(self.teststmpdir, 'fs_mark-master') os.chdir(self.sourcedir) process.run('make') build.make(self.sourcedir) self.disk = self.params.get('disk', default=None) self.num = self.params.get('num_files', default='1024') self.size = self.params.get('size', default='1000') self.dir = self.params.get('dir', default=self.srcdir) self.fstype = self.params.get('fs', default='ext4') if self.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("Test will run on %s", self.dir) self.log.info("Unmounting the disk before creating file system") self.part_obj.unmount() self.log.info("creating file system") self.part_obj.mkfs(self.fstype) self.log.info("Mounting disk %s on dir %s", self.disk, self.dir) self.part_obj.mount()
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): sm = SoftwareManager() dist = distro.detect() packages = ['gcc', 'dejagnu', 'flex', 'bison', 'texinfo'] if dist.name == 'Ubuntu': packages.extend(['g++', 'binutils-dev']) # 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 ['SuSE', 'rhel', 'fedora', 'redhat']: packages.extend(['gcc-c++', 'binutils-devel', 'texi2html']) else: self.fail('no packages list for your distro.') 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) test_type = self.params.get('type', default='upstream') if test_type == 'upstream': gdb_version = self.params.get('gdb_version', default='7.10') tarball = self.fetch_asset( "http://ftp.gnu.org/gnu/gdb/gdb-%s.tar.gz" % gdb_version) archive.extract(tarball, self.workdir) sourcedir = os.path.join( self.workdir, os.path.basename(tarball.split('.tar')[0])) elif test_type == 'distro': sourcedir = os.path.join(self.workdir, 'gdb-distro') if not os.path.exists(sourcedir): os.makedirs(sourcedir) sourcedir = sm.get_source("gdb", sourcedir) os.chdir(sourcedir) process.run('./configure', ignore_status=True, sudo=True) build.make(sourcedir)
def setUp(self): ''' Build numatop Test Source: https://github.com/01org/numatop.git ''' # Check for basic utilities # TODO: Add support for other distributions self.numa_pid = None detected_distro = distro.detect().name.lower() if not detected_distro == "ubuntu": self.cancel("Upsupported OS %s" % detected_distro) smm = SoftwareManager() for package in ['gcc', 'numatop', 'make', 'libnuma-dev']: if not smm.check_installed(package) and not smm.install(package): self.cancel("Failed to install %s, which is needed for" "the test to be run" % package) locations = ["https://github.com/01org/numatop/archive/master.zip"] tarball = self.fetch_asset("numatop.zip", locations=locations, expire='7d') archive.extract(tarball, self.srcdir) self.sourcedir = os.path.join(self.srcdir, 'numatop-master') os.chdir(self.sourcedir) build.make(self.sourcedir, extra_args='test')
def setUp(self): ''' Use 85% of memory with/without many process forked WARNING: System may go out-of-memory based on the available resource ''' smm = SoftwareManager() self.itern = int(self.params.get('iterations', default='10')) self.procs = int(self.params.get('procs', default='1')) self.minmem = int(self.params.get('minmem', default='10')) self.fails = [] if not (self.itern and self.procs and self.minmem): self.cancel( 'Please use a non-zero value for number' ' of iterations, processes and memory to be used') self.freemem = int((0.85 * memory.freememtotal()) / 1024) # Check for basic utilities for packages in ['gcc', 'make']: if not smm.check_installed(packages) and not smm.install(packages): self.cancel('%s is needed for the test to be run' % packages) shutil.copyfile(self.get_data('forkoff.c'), os.path.join(self.teststmpdir, 'forkoff.c')) shutil.copyfile(self.get_data('Makefile'), os.path.join(self.teststmpdir, 'Makefile')) build.make(self.teststmpdir)
def setUp(self): sm = SoftwareManager() detected_distro = distro.detect() self.tmpdir = data_dir.get_tmp_dir() # Check for basic utilities for package in ['gcc', 'make', 'gfortran']: if detected_distro.name == "SuSE" and package == "gfortran": package = 'gcc-fortran' # 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", "redhat"] and package == "gfortran": package = 'gcc-gfortran' if not sm.check_installed(package) and not sm.install(package): self.error(package + ' is needed for the test to be run') atlas_url = 'https://sourceforge.net/projects/'\ 'math-atlas/files/Stable/3.10.3/atlas3.10.3.tar.bz2' lapack_url = 'http://www.netlib.org/lapack/lapack-3.6.1.tgz' atlas_url = self.params.get('atlas_url', default=atlas_url) lapack_url = self.params.get('lapack_url', default=lapack_url) atlas_tarball = self.fetch_asset(atlas_url, expire='7d') archive.extract(atlas_tarball, self.workdir) self.atlas_dir = os.path.join(self.workdir, 'ATLAS') self.atlas_build_dir = os.path.join(self.atlas_dir, 'atlas_build_dir') os.makedirs(self.atlas_build_dir) lapack_tarball = self.fetch_asset(lapack_url, expire='7d') os.chdir(self.atlas_build_dir) config_args = '--shared -b 64 '\ '--with-netlib-lapack-tarfile=%s '\ '--cripple-atlas-performance' % lapack_tarball config_args = self.params.get('config_args', default=config_args) process.system('../configure %s' % config_args) # Tune and compile library build.make(self.atlas_build_dir)
def setUp(self): ''' Build ebizzy Source: http://liquidtelecom.dl.sourceforge.net/project/ebizzy/ebizzy/0.3 /ebizzy-0.3.tar.gz ''' sm = SoftwareManager() for package in ['gcc', 'make', 'patch']: if not sm.check_installed(package) and not sm.install(package): self.cancel("%s is needed for the test to be run" % package) tarball = self.fetch_asset('http://liquidtelecom.dl.sourceforge.net' '/project/ebizzy/ebizzy/0.3' '/ebizzy-0.3.tar.gz') archive.extract(tarball, self.workdir) version = os.path.basename(tarball.split('.tar.')[0]) self.sourcedir = os.path.join(self.workdir, version) patch = self.params.get( 'patch', default='Fix-build-issues-with-ebizzy.patch') os.chdir(self.sourcedir) p1 = 'patch -p0 < %s' % (self.get_data(patch)) process.run(p1, shell=True) process.run('[ -x configure ] && ./configure', shell=True) build.make(self.sourcedir)
def setUp(self): self.test_file = self.params.get('tmp_file', default='/tmp/dummy') self.duration = self.params.get('duration', default='30') self.threads = self.params.get( 'threads', default=cpu.online_cpus_count()) self.size = self.params.get( 'memory_to_test', default=int(0.9 * memory.meminfo.MemFree.m)) smm = SoftwareManager() for package in ['gcc', 'libtool', 'autoconf', 'automake', 'make']: if not smm.check_installed(package) and not smm.install(package): self.cancel("Failed to install %s, which is needed for" "the test to be run" % package) if not os.path.exists(self.test_file): try: os.mknod(self.test_file) except OSError: self.cancel("Skipping test since test file creation failed") loc = ["https://github.com/stressapptest/" "stressapptest/archive/master.zip"] tarball = self.fetch_asset("stressapp.zip", locations=loc, expire='7d') archive.extract(tarball, self.workdir) self.sourcedir = os.path.join(self.workdir, 'stressapptest-master') os.chdir(self.sourcedir) process.run('./configure', shell=True) build.make(self.sourcedir)
def build_module(self): """ Building of the kretprobe kernel module """ self.log.info("============== Building kretprobe Module =================") self.sourcedir = tempfile.mkdtemp() os.chdir(self.sourcedir) self.location = ('https://raw.githubusercontent.com/torvalds/linux/' 'master/samples/kprobes/kretprobe_example.c') self.kretprobe_file = self.fetch_asset(self.location, expire='7d') self.kretprobe_dst = os.path.join(self.sourcedir, 'kretprobe_example.c') shutil.copy(self.kretprobe_file, self.kretprobe_dst) """ Write module make file on the fly """ makefile = open("Makefile", "w") makefile.write('obj-m := kretprobe_example.o\nKDIR := /lib/modules/$(shell uname -r)/build' '\nPWD := $(shell pwd)\ndefault:\n\t' '$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules\n') makefile.close() self.is_fail = 0 build.make(self.sourcedir) if self.is_fail >= 1: self.fail("Building kretprobe_example.ko failed") if not os.path.isfile('./kretprobe_example.ko'): self.fail("No kretprobe_example.ko found, module build failed")
def setUp(self): ''' Build Ioping Test ''' # Check for basic utilities smm = SoftwareManager() self.count = self.params.get('count', default='2') self.mode = self.params.get('mode', default='-C') self.deadline = self.params.get('deadline', default='10') self.period = self.params.get('period', default='10') self.interval = self.params.get('interval', default='1s') self.size = self.params.get('size', default='4k') self.wsize = self.params.get('wsize', default='10m') self.disk = self.params.get('disk', default='/home') for package in ['gcc', 'make']: if not smm.check_installed(package) and not smm.install(package): self.cancel( "Fail to install %s required for this test." % package) tarball = self.fetch_asset('https://storage.googleapis.com/' 'google-code-archive-downloads/v2/' 'code.google.com/ioping/' 'ioping-0.8.tar.gz', expire='0d') archive.extract(tarball, self.teststmpdir) version = os.path.basename(tarball.split('.tar.')[0]) self.sourcedir = os.path.join(self.teststmpdir, version) build.make(self.sourcedir)
def setUp(self): ''' Build ebizzy ''' if 'ppc' not in distro.detect().arch: self.cancel("Processor is not ppc64") smg = SoftwareManager() detected_distro = distro.detect() deps = ['gcc', 'make', 'patch'] if 'Ubuntu' in detected_distro.name: deps.extend(['linux-tools-common', 'linux-tools-%s' % platform.uname()[2]]) elif detected_distro.name == "SuSE": deps.extend(['cpupower']) else: deps.extend(['kernel-tools']) for package in deps: if not smg.check_installed(package) and not smg.install(package): self.cancel("%s is needed for the test to be run" % package) tarball = self.fetch_asset('http://liquidtelecom.dl.sourceforge.net' '/project/ebizzy/ebizzy/0.3' '/ebizzy-0.3.tar.gz') archive.extract(tarball, self.workdir) version = os.path.basename(tarball.split('.tar.')[0]) self.sourcedir = os.path.join(self.workdir, version) patch = self.params.get( 'patch', default='Fix-build-issues-with-ebizzy.patch') os.chdir(self.sourcedir) fix_patch = 'patch -p0 < %s' % (self.get_data(patch)) process.run(fix_patch, shell=True) process.run("./configure") build.make(self.sourcedir)
def setUp(self): ''' Build posixtest Source: http://ufpr.dl.sourceforge.net/sourceforge/posixtest/posixtestsuite-1.5.2.tar.gz ''' sm = SoftwareManager() for package in ['gcc', 'make', 'patch']: if not sm.check_installed(package) and not sm.install(package): self.cancel("%s is needed for the test to be run" % package) tarball = self.fetch_asset('http://ufpr.dl.sourceforge.net' '/sourceforge/posixtest/posixtestsuite-1.5.2.tar.gz') data_dir = os.path.abspath(self.datadir) archive.extract(tarball, self.srcdir) version = os.path.basename(tarball.split('-1.')[0]) self.sourcedir = os.path.join(self.srcdir, version) patch = self.params.get( 'patch', default='posix-linux.patch') os.chdir(self.sourcedir) p1 = 'patch -p1 < %s/%s' % (data_dir, patch) process.run(p1, shell=True) build.make(self.sourcedir)
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): ''' 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): 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): ''' Check for required packages namely gcc, make, valgrind. Transfer the source file and make file. Compile ''' smm = SoftwareManager() dist = distro.detect() if dist.arch != "ppc64le": self.cancel("Test is not applicable!!") deps = ['gcc', 'make', 'valgrind'] 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) self.log.info("Tranferring the files ...") shutil.copyfile(self.get_data('print_power_time_base.c'), os.path.join(self.teststmpdir, 'print_power_time_base.c')) self.log.info("About to compile ...") shutil.copyfile(self.get_data('Makefile'), os.path.join(self.teststmpdir, 'Makefile')) build.make(self.teststmpdir)
def setUp(self): ''' Build ebizzy Source: http://liquidtelecom.dl.sourceforge.net/project/ebizzy/ebizzy/0.3 /ebizzy-0.3.tar.gz ''' sm = SoftwareManager() if not sm.check_installed("gcc") and not sm.install("gcc"): self.error("Gcc is needed for the test to be run") tarball = self.fetch_asset('http://liquidtelecom.dl.sourceforge.net' '/project/ebizzy/ebizzy/0.3' '/ebizzy-0.3.tar.gz') data_dir = os.path.abspath(self.datadir) archive.extract(tarball, self.srcdir) version = os.path.basename(tarball.split('.tar.')[0]) self.srcdir = os.path.join(self.srcdir, version) patch = self.params.get( 'patch', default='Fix-build-issues-with-ebizzy.patch') os.chdir(self.srcdir) p1 = 'patch -p0 < %s/%s' % (data_dir, patch) process.run(p1, shell=True) process.run('[ -x configure ] && ./configure', shell=True) build.make(self.srcdir)
def setUp(self): ''' Build linsched Test Source: https://github.com/thejinxters/linux-scheduler-testing ''' # Check for basic utilities smm = SoftwareManager() deps = ['gcc', 'make', 'patch'] if distro.detect().name == "SuSE": deps.append('git-core') else: deps.append('git') for package in deps: if not smm.check_installed(package) and not smm.install(package): self.cancel( "Fail to install %s required for this test." % package) self.args = self.params.get('args', default='pi 100') git.get_repo('https://github.com/thejinxters/linux-scheduler-testing', destination_dir=self.srcdir) os.chdir(self.srcdir) fix_patch = 'patch -p1 < %s' % ( os.path.join(self.datadir, 'fix.patch')) process.run(fix_patch, shell=True, ignore_status=True) build.make(self.srcdir)
def setUp(self): """ Build xfstest Source: git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git """ sm = SoftwareManager() packages = ['xfslibs-dev', 'uuid-dev', 'libtool-bin', 'e2fsprogs', 'automake', 'gcc', 'libuuid1', 'quota', 'attr', 'libattr1-dev', 'make', 'libacl1-dev', 'xfsprogs', 'libgdbm-dev', 'gawk', 'fio', 'dbench', 'uuid-runtime'] for package in packages: if not sm.check_installed(package) and not sm.install(package): self.error("Fail to install %s required for this test." % package) self.test_range = self.params.get('test_range', default=None) if self.test_range is None: self.fail('Please provide a test_range.') self.skip_dangerous = self.params.get('skip_dangerous', default=True) git.get_repo('git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git', destination_dir=self.srcdir) data_dir = os.path.abspath(self.datadir) shutil.copyfile(os.path.join(data_dir, 'group'), os.path.join(self.srcdir, 'group')) build.make(self.srcdir) self.available_tests = self._get_available_tests() self.test_list = self._create_test_list() self.log.info("Tests available in srcdir: %s", ", ".join(self.available_tests)) process.run('useradd fsgqa', sudo=True) process.run('useradd 123456-fsgqa', sudo=True)
def setUp(self): ''' Build 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): softm = SoftwareManager() pkgs = ['gcc', 'make'] if distro.detect().name in ['SuSE', 'Ubuntu']: pkgs.extend(['libpfm4']) else: pkgs.extend(['libpfm']) for pkg in pkgs: if not softm.check_installed(pkg) and not softm.install(pkg): self.cancel("%s is needed for the test to be run" % pkg) test_type = self.params.get('type', default='upstream') if test_type == 'upstream': tarball = self.fetch_asset( 'https://netix.dl.sourceforge.net/project/perfmon2/' 'libpfm4/libpfm-4.9.0.tar.gz', expire='1d') archive.extract(tarball, self.teststmpdir) version = os.path.basename(tarball.split('.tar.')[0]) self.path = os.path.join(self.teststmpdir, version) elif test_type == 'distro': sourcedir = os.path.join(self.teststmpdir, 'libpfm-distro') if not os.path.exists(sourcedir): os.makedirs(sourcedir) if distro.detect().name == 'Ubuntu': self.path = softm.get_source('libpfm4', sourcedir) else: self.path = softm.get_source('libpfm', sourcedir) os.chdir(self.path) build.make(self.path)
def setUp(self): ''' Build Integrity Test ''' # Check for basic utilities smm = SoftwareManager() self.scenario_arg = self.params.get('scenario_arg', default='1') if self.scenario_arg not in ['1', '2', '3']: self.cancel("Test need to skip as scenario needs to be 1-3") detected_distro = distro.detect() deps = ['gcc', 'make'] if detected_distro.name == "Ubuntu": deps.extend(['libnuma-dev']) elif detected_distro.name in ["centos", "rhel", "fedora"]: deps.extend(['numactl-devel']) else: deps.extend(['libnuma-devel']) for packages in deps: if not smm.check_installed(packages) and not smm.install(packages): self.cancel('%s is needed for the test to be run' % packages) archive.extract(self.get_data("Integritytests.tar"), self.workdir) self.build_dir = os.path.join(self.workdir, 'Integritytests') build.make(self.build_dir)
def setUp(self): smm = SoftwareManager() dist = distro.detect() memsize = int(memory.meminfo.MemFree.b * 0.2) self.nr_pages = self.params.get('nr_pages', default=memsize // memory.get_page_size()) self.map_type = self.params.get('map_type', default='private') self.hpage = self.params.get('h_page', default=False) nodes = memory.numa_nodes_with_memory() pkgs = ['gcc', 'make'] hp_check = 0 if self.hpage: hp_size = memory.get_huge_page_size() for node in nodes: genio.write_file( '/sys/devices/system/node/node%s/hugepages/hu' 'gepages-%skB/nr_hugepages' % (node, str(hp_size)), str(self.nr_pages)) for node in nodes: hp_check += int( genio.read_file( '/sys/devices/system/node/node%s/hugepages/hugepages-%skB' '/nr_hugepages' % (node, str(hp_size))).strip()) if hp_check < self.nr_pages: self.cancel('Not enough pages to be configured on nodes') if dist.name in ["Ubuntu", 'debian']: pkgs.extend( ['libpthread-stubs0-dev', 'libnuma-dev', 'libhugetlbfs-dev']) elif dist.name in ["centos", "rhel", "fedora"]: pkgs.extend(['numactl-devel', 'libhugetlbfs-devel']) elif dist.name == "SuSE": pkgs.extend(['libnuma-devel']) if dist.version >= 15: pkgs.extend(['libhugetlbfs-devel']) else: pkgs.extend(['libhugetlbfs-libhugetlb-devel']) for package in pkgs: 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 [ 'util.c', 'numa_test.c', 'softoffline.c', 'bench_movepages.c', 'Makefile' ]: self.copyutil(file_name) build.make(self.teststmpdir)
def setUp(self): """ Build 'doublefree'. """ source = self.params.get('source', default='doublefree.c') c_file = self.get_data(source) if c_file is None: self.cancel('Test is missing data file %s' % source) c_file_name = os.path.basename(c_file) dest_c_file = os.path.join(self.workdir, c_file_name) shutil.copy(c_file, dest_c_file) build.make(self.workdir, env={'CFLAGS': '-g -O0'}, extra_args='doublefree')
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.dirs = self.params.get('dir', default=self.workdir) fstype = self.params.get('fs', default='ext4') tarball = self.fetch_asset(url) archive.extract(tarball, self.teststmpdir) self.sourcedir = os.path.join(self.teststmpdir, "fio") build.make(self.sourcedir) smm = SoftwareManager() if fstype == 'btrfs': ver = int(distro.detect().version) rel = int(distro.detect().release) if distro.detect().name == 'rhel': if (ver == 7 and rel >= 4) or ver > 7: self.cancel("btrfs is not supported with \ RHEL 7.4 onwards") if distro.detect().name in ['Ubuntu', 'debian']: pkg_list = ['libaio-dev'] if fstype == 'btrfs': pkg_list.append('btrfs-progs') else: pkg_list = ['libaio', 'libaio-devel'] for pkg in pkg_list: if pkg and not smm.check_installed(pkg) and not smm.install(pkg): self.cancel( "Package %s is missing and could not be installed" % pkg) if self.disk is not None: self.part_obj = Partition(self.disk, mountpoint=self.dirs) self.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.dirs) try: self.part_obj.mount() except PartitionError: self.fail("Mounting disk %s on directory %s failed" % (self.disk, self.dirs)) self.fio_file = 'fiotest-image'
def setUp(self): """ Build 'stress'. Source: http://people.seas.harvard.edu/~apw/stress/stress-1.0.4.tar.gz """ tarball = self.fetch_asset( 'http://people.seas.harvard.edu/~apw/stress/stress-1.0.4.tar.gz') archive.extract(tarball, self.srcdir) stress_version = os.path.basename(tarball.split('.tar.')[0]) self.srcdir = os.path.join(self.srcdir, stress_version) os.chdir(self.srcdir) process.run('./configure') build.make(self.srcdir)
def test(self): """ Execute the kernel selftest """ self.error = False build.make(self.sourcedir, extra_args='%s run_tests' % self.comp) for line in open(os.path.join(self.logdir, 'debug.log')).readlines(): if self.run_type == 'upstream': self.find_match(r'not ok (.*) selftests:(.*)', line) elif self.run_type == 'distro': self.find_match(r'selftests:(.*)\[FAIL\]', line) if self.error: self.fail("Testcase failed during selftests")
def setUp(self): sm = SoftwareManager() for package in ['gcc', 'make']: if not sm.check_installed(package) and not sm.install(package): self.cancel('%s is needed for the test to be run' % package) tarball = self.fetch_asset( "https://www.samba.org/ftp/tridge/dbench/dbench-3.04.tar.gz", expire='7d') archive.extract(tarball, self.workdir) version = os.path.basename(tarball.split('.tar.')[0]) self.sourcedir = os.path.join(self.workdir, version) os.chdir(self.sourcedir) process.run('./configure', ignore_status=True, sudo=True) build.make(self.sourcedir)
def test_gpu_burn(self): ''' GPU burn tests ''' self.log.info("test_gpu_burn: GPU Burn tests") git.get_repo('https://github.com/wilicc/gpu-burn.git', destination_dir=self.workdir) os.chdir(self.workdir) build.make(self.workdir) output = process.system_output('./gpu_burn', ignore_status=True, shell=True) self.process_output(output)
def setUp(self): ''' Build IOZone Source: http://www.iozone.org/src/current/iozone3_434.tar ''' self.base_dir = os.path.abspath(self.basedir) tarball = self.fetch_asset( 'http://www.iozone.org/src/current/iozone3_434.tar') archive.extract(tarball, self.srcdir) version = os.path.basename(tarball.split('.tar')[0]) self.srcdir = os.path.join(self.srcdir, version) make_dir = os.path.join(self.srcdir, 'src', 'current') os.chdir(make_dir) patch = self.params.get('patch', default='makefile.patch') patch = os.path.join(self.datadir, patch) process.run('patch -p3 < %s' % patch, shell=True) d_distro = distro.detect() arch = d_distro.arch if arch == 'ppc': build.make(make_dir, extra_args='linux-powerpc') elif arch == 'ppc64' or arch == 'ppc64le': build.make(make_dir, extra_args='linux-powerpc64') elif arch == 'x86_64': build.make(make_dir, extra_args='linux-AMD64') else: build.make(make_dir, extra_args='linux')
def setUp(self): ''' 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.srcdir) version = os.path.basename(tarball.split('.tar')[0]) self.srcdir = os.path.join(self.srcdir, version) make_dir = os.path.join(self.srcdir, 'src', 'current') os.chdir(make_dir) patch = self.params.get('patch', default='makefile.patch') patch = os.path.join(self.datadir, patch) process.run('patch -p3 < %s' % patch, shell=True) d_distro = distro.detect() arch = d_distro.arch if arch == 'ppc': build.make(make_dir, extra_args='linux-powerpc') elif arch == 'ppc64' or arch == 'ppc64le': build.make(make_dir, extra_args='linux-powerpc64') elif arch == 'x86_64': build.make(make_dir, extra_args='linux-AMD64') else: build.make(make_dir, extra_args='linux')
def setUp(self): """ To check and install dependencies for the test """ smm = SoftwareManager() detected_distro = distro.detect() pkgs = ["gcc", "autoconf", "perl", "m4", "git-core"] 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) 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.peer_user = self.params.get("peer_user_name", default="root") uperf_download = self.params.get("uperf_download", default="https:" "//github.com/uperf/uperf/" "archive/master.zip") tarball = self.fetch_asset(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 = "ssh %s@%s \"cd /tmp/uperf-master;autoreconf -fi;./configure " \ "ppc64le;make\"" % (self.peer_user, self.peer_ip) if process.system(cmd, ignore_status=True, shell=True, sudo=True): 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 = "ssh %s@%s \"cd /tmp/uperf-master/src;./uperf -s\""\ % (self.peer_user, self.peer_ip) obj = process.SubProcess(cmd, verbose=False, shell=True) 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") speed = int(read_file("/sys/class/net/%s/speed" % self.iface)) self.expected_tp = int(self.expected_tp) * speed / 100
def setUp(self): """ Build 'stress'. Source: http://people.seas.harvard.edu/~apw/stress/stress-1.0.4.tar.gz """ stress_tarball = self.params.get('stress_tarball', default='stress-1.0.4.tar.gz') tarball_path = self.get_data_path(stress_tarball) archive.extract(tarball_path, self.srcdir) stress_version = stress_tarball.split('.tar.')[0] self.srcdir = os.path.join(self.srcdir, stress_version) os.chdir(self.srcdir) process.run('./configure') build.make(self.srcdir)
def setUp(self): ''' Setup Flail ''' smm = SoftwareManager() for package in ['gcc', 'make']: if not smm.check_installed(package) and not smm.install(package): self.cancel(package + ' is needed for the test to be run') self.fs_type = self.params.get('fstype', default='xfs') tarball = os.path.join(self.datadir, "flail-0.2.0.tar.gz") archive.extract(tarball, self.workdir) self.build_dir = os.path.join(self.workdir, 'flail-0.2.0') build.make(self.build_dir)
def setUp(self): """ Build bonnie++ Source: http://www.coker.com.au/bonnie++/experimental/bonnie++-1.96.tgz """ bonnie_tarball = self.params.get('bonnie_tarball', default='bonnie++-1.96.tgz') tarball_path = self.get_data_path(bonnie_tarball) archive.extract(tarball_path, self.srcdir) bonnie_version = bonnie_tarball.split('.tgz')[0] self.srcdir = os.path.join(self.srcdir, bonnie_version) os.chdir(self.srcdir) process.run('./configure') build.make(self.srcdir)
def setUp(self): """ Build the synctest suite. """ self.cwd = os.getcwd() tarball_path = self.get_data_path( self.params.get('sync_tarball', '*', 'synctest.tar.bz2')) archive.extract(tarball_path, self.srcdir) self.srcdir = os.path.join(self.srcdir, 'synctest') if self.params.get('debug_symbols', default=True): build.make(self.srcdir, env={'CFLAGS': '-g -O0'}, extra_args='synctest') else: build.make(self.srcdir)
def setUp(self): """ fs_mark """ tarball = self.fetch_asset('http://prdownloads.source' 'forge.net/fsmark/fs_mark-3.3.tar.gz') archive.extract(tarball, self.srcdir) fs_version = os.path.basename(tarball.split('.tar.')[0]) self.srcdir = os.path.join(self.srcdir, fs_version) os.chdir(self.srcdir) process.run('make') build.make(self.srcdir) self.disk = self.params.get('disk', default=None) self.fstype = self.params.get('fs', default='ext4')
def setUp(self): """ Build 'stress'. Source: https://fossies.org/linux/privat/stress-1.0.4.tar.gz """ tarball = self.fetch_asset( 'https://fossies.org/linux/privat/stress-1.0.4.tar.gz', expire='7d') archive.extract(tarball, self.workdir) stress_version = os.path.basename(tarball.split('.tar.')[0]) self.sourcedir = os.path.join(self.workdir, stress_version) os.chdir(self.sourcedir) process.run('./configure') build.make(self.sourcedir)
def setUp(self): smm = SoftwareManager() self.memsize = int( self.params.get('memory_size', default=(memory.meminfo.MemFree.m * 0.5)) * 1048576) self.induce_err = self.params.get('induce_err', default=0) for package in ['gcc', 'make']: if not smm.check_installed(package) and not smm.install(package): self.cancel('%s is needed for the test to be run' % package) for file_name in ['memory_api.c', 'mremap.c', 'Makefile']: self.copyutil(file_name) build.make(self.teststmpdir)
def setUp(self): ''' Setup Flail ''' smm = SoftwareManager() for package in ['gcc', 'make']: if not smm.check_installed(package) and not smm.install(package): self.cancel(package + ' is needed for the test to be run') self.fs_type = self.params.get('fstype', default='xfs') archive.extract(self.get_data("flail-0.2.0.tar.gz"), self.workdir) self.build_dir = os.path.join(self.workdir, 'flail-0.2.0') os.chdir(self.build_dir) process.system("sed -i 's/.*-lm.*/& -lm' Makefile") build.make(self.build_dir)
def setUp(self): ''' Build fsfuzzer Source: https://github.com/stevegrubb/fsfuzzer.git ''' detected_distro = distro.detect() d_name = detected_distro.name.lower() smm = SoftwareManager() deps = ['gcc', 'patch', 'libtool', 'autoconf', 'automake', 'make'] if d_name == 'ubuntu': deps.extend(['libattr1-dev']) else: deps.extend(['libattr-devel']) for package in deps: if not smm.check_installed(package) and not smm.install(package): self.cancel("Fail to install/check %s, which is needed for" "fsfuzz to run" % package) locations = [ "https://github.com/stevegrubb/fsfuzzer/archive/" "master.zip" ] tarball = self.fetch_asset("fsfuzzer.zip", locations=locations) archive.extract(tarball, self.srcdir) os.chdir(os.path.join(self.srcdir, "fsfuzzer-master")) if d_name == "ubuntu": # Patch for ubuntu fuzz_fix_patch = 'patch -p1 < %s' % (os.path.join( self.datadir, 'fsfuzz_fix.patch')) if process.system(fuzz_fix_patch, shell=True, ignore_status=True): self.log.warn("Unable to apply sh->bash patch!") process.run('./autogen.sh', shell=True) process.run('./configure', shell=True) build.make('.') self._args = self.params.get('fstype', default='') self._fsfuzz = os.path.abspath(os.path.join('.', "fsfuzz")) fs_sup = process.system_output('%s %s' % (self._fsfuzz, ' --help')) match = re.search(r'%s' % self._args, fs_sup, re.M | re.I) if not match: self.cancel('File system ' + self._args + ' is unsupported in ' + detected_distro.name)
def setUp(self): smm = SoftwareManager() detected_distro = distro.detect() # TODO: Add debs for Ubuntu. if detected_distro.name == "Ubuntu": self.cancel("Skip the test for ubuntu as debs needs to be" "added in packages") packages = [ 'make', 'gcc', 'systemtap', 'systemtap-runtime', 'elfutils', 'kernel-devel', 'dejagnu' ] # 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 ["redhat", "rhel"]: packages.extend([ 'git', 'kernel-debug', 'kernel-debuginfo', 'kernel-debug-debuginfo', 'elfutils-devel' ]) if detected_distro.name == "SuSE": packages.extend([ 'git-core', 'kernel-default-devel', 'libebl1', 'kernel-default-debuginfo', 'kernel-devel', 'kernel-macros', 'libdw-devel', 'libebl-devel', 'libelf-devel' ]) 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) git.get_repo('git://sourceware.org/git/systemtap.git', destination_dir=self.workdir) os.chdir(self.workdir) process.run('./configure', ignore_status=True, sudo=True) build.make(self.workdir) build.make(self.workdir, extra_args='install') self.test_dir = os.path.join(self.workdir, "testsuite") os.chdir(self.test_dir) # Run a simple systemtap script to make sure systemtap and the # kernel debuginfo packages are correctly installed script_result = process.system( "PATH=%s/bin:$PATH stap -v /bin/true " "-e 'probe vfs.read { exit()" " }'", ignore_status=True, sudo=True, shell=True) if script_result != 0: self.cancel("simple systemtap test failed," "kernel debuginfo package may be missing")
def setUp(self): smm = SoftwareManager() detected_distro = distro.detect() self.stressors = self.params.get('stressors', default=None) self.ttimeout = self.params.get('ttimeout', default='300') self.workers = self.params.get( 'workers', default=multiprocessing.cpu_count()) self.class_type = self.params.get('class', default='all') self.verify = self.params.get('verify', default=True) self.syslog = self.params.get('syslog', default=True) self.metrics = self.params.get('metrics', default=True) self.maximize = self.params.get('maximize', default=True) self.times = self.params.get('times', default=True) self.aggressive = self.params.get('aggressive', default=True) self.exclude = self.params.get('exclude', default=None) self.v_stressors = self.params.get('v_stressors', default=None) self.parallel = self.params.get('parallel', default=True) deps = ['gcc', 'make'] if 'Ubuntu' in detected_distro.name: deps.extend([ 'libaio-dev', 'libapparmor-dev', 'libattr1-dev', 'libbsd-dev', 'libcap-dev', 'libgcrypt11-dev', 'libkeyutils-dev', 'libsctp-dev', 'zlib1g-dev']) else: deps.extend(['libattr-devel', 'libbsd-devel', 'libcap-devel', 'libgcrypt-devel', 'keyutils-libs-devel', 'zlib-devel', 'libaio-devel']) for package in deps: if not smm.check_installed(package) and not smm.install(package): self.log.info( '%s is needed, get the source and build', package) tarball = self.fetch_asset('stressng.zip', locations=['https://github.com/Colin' 'IanKing/stress-ng/archive' '/master.zip'], expire='7d') archive.extract(tarball, self.workdir) sourcedir = os.path.join(self.workdir, 'stress-ng-master') os.chdir(sourcedir) result = build.run_make(sourcedir, process_kwargs={'ignore_status': True}) for line in str(result).splitlines(): if 'error:' in line: self.cancel( "Unsupported OS, Please check the build logs !!") build.make(sourcedir, extra_args='install') clear_dmesg()
def setUp(self): ''' Install the basic packages to support audit ''' # Check for basic utilities smm = SoftwareManager() detected_distro = distro.detect() deps = ['gcc', 'make'] if detected_distro.name in [ 'rhel', 'SuSE', 'fedora', 'centos', 'redhat' ]: deps.extend([ "glibc", "glibc-devel", "libgcc", "perl", "perl-Test", "perl-Test-Harness", "perl-File-Which", "perl-Time-HiRes", "nmap-ncat" ]) else: self.cancel("Install the package for audit 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) url = ("https://github.com/linux-audit/audit-testsuite/archive/" "refs/heads/main.zip") tarball = self.fetch_asset(url, expire='7d') archive.extract(tarball, self.workdir) self.sourcedir = os.path.join(self.workdir, 'audit-testsuite-main') os.chdir(self.sourcedir) if build.make(self.sourcedir) > 0: self.cancel("Building audit test suite failed")
def build_perf_test(self): """ Building the perf event test suite """ self.sourcedir = os.path.join(self.workdir, 'perf_event_tests-master') if build.make(self.sourcedir, extra_args="-s -S") > 0: self.cancel("Building perf event test suite failed")
def setUp(self): """ Build the synctest suite. """ self.cwd = os.getcwd() sync_tarball = self.params.get("sync_tarball", "*", "synctest.tar.bz2") tarball_path = self.get_data(sync_tarball) if tarball_path is None: self.cancel(f"Test is missing data file {tarball_path}") archive.extract(tarball_path, self.workdir) srcdir = os.path.join(self.workdir, "synctest") os.chdir(srcdir) if self.params.get("debug_symbols", default=True): build.make(srcdir, env={"CFLAGS": "-g -O0"}, extra_args="synctest") else: build.make(srcdir)
def setUp(self): # Check for basic utilities smm = SoftwareManager() for package in ("gcc", "make"): if not smm.check_installed(package) and not smm.install(package): self.cancel("Fail to install %s required for this test." % package) git.get_repo('git://git.code.sf.net/p/perfmon2/libpfm4', destination_dir=self.workdir) os.chdir(self.workdir) build.make('.')
def setUp(self): sm = SoftwareManager() for package in ['gcc', 'make']: if not sm.check_installed(package) and not sm.install(package): self.cancel("Fail to install %s required for this test." % package) gsl_version = self.params.get('gsl_version', default='2.2') tarball = self.fetch_asset("ftp://ftp.gnu.org/gnu/gsl/gsl-%s.tar.gz" % gsl_version, expire='10d') archive.extract(tarball, self.workdir) self.sourcedir = os.path.join( self.workdir, os.path.basename(tarball.split('.tar')[0])) os.chdir(self.sourcedir) process.run('./configure', ignore_status=True, sudo=True) build.make(self.sourcedir)
def build_module(self): """ Building of the livepatching kernel module """ self.log.info( "============== Building livepatching Module =================") self.sourcedir = tempfile.mkdtemp() os.chdir(self.sourcedir) self.location = ('https://raw.githubusercontent.com/torvalds/linux/' 'master/samples/livepatch/livepatch-sample.c') self.livepatch_file = self.fetch_asset(self.location, expire='7d') self.livepatch_dst = os.path.join(self.sourcedir, 'livepatch-sample.c') shutil.copy(self.livepatch_file, self.livepatch_dst) """ Write module make file on the fly """ makefile = open("Makefile", "w") makefile.write('obj-m := livepatch-sample.o\nKDIR ' ':= /lib/modules/$(shell uname -r)/build' '\nPWD := $(shell pwd)\ndefault:\n\t' '$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules\n') makefile.close() if build.make(self.sourcedir) >= 1: self.fail("Building livepatch-sample.ko failed") if not os.path.isfile('./livepatch-sample.ko'): self.fail("No livepatch-sample.ko found, module build failed")
def setUp(self): ''' Install the basic packages to support libgcrypt ''' # Check for basic utilities smm = SoftwareManager() detected_distro = distro.detect() deps = ['gcc', 'make'] if detected_distro.name in ['rhel', 'SuSE', 'fedora', 'centos']: deps.extend([ "autoconf", "automake", "libgpg-error-devel", "libgpg-error", "transfig" ]) else: self.cancel("Unsupported distro %s for libgcrypt package" % 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) url = "https://dev.gnupg.org/source/libgcrypt.git" git.get_repo(url, destination_dir=self.workdir) os.chdir(self.workdir) process.run("./autogen.sh") process.run("./configure --enable-maintainer-mode") if build.make(self.workdir): # If the make fails then need to run make with -lpthread build.run_make(self.workdir, extra_args="CFLAGS+=-lpthread", process_kwargs={"ignore_status": True})
def test_cuda_uvm(self): ''' GPU Unified tests ''' self.log.info("test_cuda_uvm: GPU Unified tests") self.ld_path = "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64:\ /usr/local/cuda/extras/CUPTI/lib64" test_dir = "/usr/local/cuda/extras/CUPTI/samples/unified_memory/" exp_cmd = "export %s" % self.ld_path process.system(exp_cmd, ignore_status=True, shell=True) build.make(test_dir) os.chdir(test_dir) uvm_cmd="/usr/local/cuda/extras/CUPTI/samples/unified_memory/unified_memory" output = process.system_output(uvm_cmd, ignore_status=True, shell=True) self.process_output(output)
def setUp(self): """ Build the synctest suite. """ self.cwd = os.getcwd() sync_tarball = self.params.get('sync_tarball', '*', 'synctest.tar.bz2') tarball_path = self.get_data(sync_tarball) if tarball_path is None: self.cancel('Test is missing data file %s' % tarball_path) archive.extract(tarball_path, self.workdir) srcdir = os.path.join(self.workdir, 'synctest') os.chdir(srcdir) if self.params.get('debug_symbols', default=True): build.make(srcdir, env={'CFLAGS': '-g -O0'}, extra_args='synctest') else: build.make(srcdir)