def setup_nvdimm(self): """ Setup pmem devices """ self.plib = pmem.PMem() regions = sorted(self.plib.run_ndctl_list('-R'), key=lambda i: i['size'], reverse=True) if not regions: self.plib.enable_region() regions = sorted(self.plib.run_ndctl_list('-R'), key=lambda i: i['size'], reverse=True) self.region = self.plib.run_ndctl_list_val(regions[0], 'dev') if self.plib.run_ndctl_list('-N -r %s' % self.region): self.plib.destroy_namespace(region=self.region, force=True) self.plib.create_namespace(region=self.region) disk_id = "/dev/%s" % self.plib.run_ndctl_list_val( self.plib.run_ndctl_list('-N -r %s' % self.region)[0], 'blockdev') self.mnt_dir = '/pmem' self.part_obj = partition.Partition(disk_id, mountpoint=self.mnt_dir) self.log.info("Creating file system") self.part_obj.mkfs(fstype='ext4', args='-b 64k -F') self.log.info("Mounting disk %s", disk_id) if not os.path.exists(self.mnt_dir): os.makedirs(self.mnt_dir) try: self.part_obj.mount(args='-o dax') except partition.PartitionError: self.cancel("Mounting disk %s on directory failed" % disk_id) return os.path.join(self.mnt_dir, "file")
def setUp(self): """ Build 'ndctl' and setup the binary. """ if "powerpc" not in cpu.get_cpu_arch(): self.cancel("Test supported only on POWER arch") deps = [] self.dist = distro.detect() self.package = self.params.get('package', default='distro') if self.dist.name not in ['SuSE', 'rhel']: self.cancel('Unsupported OS %s' % self.dist.name) 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']) 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) 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 " "--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.plib = pmem.PMem(self.ndctl, self.daxctl) if not self.plib.check_buses(): self.cancel("Test needs atleast one region")
def setup_pmem_disk(self, mnt_args): if not self.disk: self.plib = pmem.PMem() regions = sorted(self.plib.run_ndctl_list( '-R'), key=lambda i: i['size'], reverse=True) if not regions: self.plib.enable_region() regions = sorted(self.plib.run_ndctl_list( '-R'), key=lambda i: i['size'], reverse=True) region = self.plib.run_ndctl_list_val(regions[0], 'dev') if self.plib.run_ndctl_list("-N -r %s" % region): self.plib.destroy_namespace(region=region, force=True) if 'dax' in mnt_args: self.plib.create_namespace(region=region) self.disk = "/dev/%s" % self.plib.run_ndctl_list_val( self.plib.run_ndctl_list('-N -r %s' % region)[0], 'blockdev') else: self.plib.create_namespace( region=region, mode='devdax') self.devdax_file = "/dev/%s" % self.plib.run_ndctl_list_val( self.plib.run_ndctl_list('-N -r %s' % region)[0], 'chardev')
def setup_nvdimm(self): self.logflag = self.params.get('logdev', default=False) self.plib = pmem.PMem() self.plib.enable_region() regions = sorted(self.plib.run_ndctl_list('-R'), key=lambda i: i['size'], reverse=True) if not regions: self.cancel("Nvdimm test with no region support") self.region = self.plib.run_ndctl_list_val(regions[0], 'dev') if self.plib.is_region_legacy(self.region): if not len(regions) > 1: self.cancel("Not supported with single legacy region") if self.logflag: self.log.info("Using loop devices as log devices") check = 2 mount = True 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(None, '2038M', mount) self.log_test = self.devices.pop() self.log_scratch = self.devices.pop() namespaces = self.plib.run_ndctl_list('-N -r %s' % self.region) pmem_dev = self.plib.run_ndctl_list_val(namespaces[0], 'blockdev') self.test_dev = "/dev/%s" % pmem_dev region_2 = self.plib.run_ndctl_list_val(regions[1], 'dev') namespaces = self.plib.run_ndctl_list('-N -r %s' % region_2) pmem_dev = self.plib.run_ndctl_list_val(namespaces[0], 'blockdev') self.scratch_dev = "/dev/%s" % pmem_dev self.devices.extend([self.test_dev, self.scratch_dev]) else: if self.logflag: if not len(regions) > 1: self.log.info('Using 10% space of device for logdev') self.region_ldev = self.region region_size = self.plib.run_ndctl_list_val( self.plib.run_ndctl_list('-r %s' % self.region_ldev)[0], 'size') logdev_size = int(region_size * 0.10) dev_size = region_size - logdev_size size_align = self.get_size_alignval() dev_size = dev_size // 2 dev_size = (dev_size // size_align) * size_align logdev_size = logdev_size // 2 logdev_size = (logdev_size // size_align) * size_align else: dev_size = self.get_half_region_size(self.region) self.region_ldev = self.plib.run_ndctl_list_val( regions[1], 'dev') logdev_size = self.get_half_region_size( region=self.region_ldev) self.plib.destroy_namespace(region=self.region, force=True) self.plib.destroy_namespace(region=self.region_ldev, force=True) # XFS restrict max log size to 2136997888, which is 10M less # than 2GB, not 16M page-aligned, hence rounding-off to nearest # 16M align value 2130706432, which is 16M less than 2GiB logdev_size = min(logdev_size, 2130706432) # log device to be created in sector mode self.plib.create_namespace(region=self.region_ldev, mode='sector', sector_size='512', size=logdev_size) self.plib.create_namespace(region=self.region_ldev, mode='sector', sector_size='512', size=logdev_size) namespaces = self.plib.run_ndctl_list('-N -r %s -m sector' % self.region_ldev) log_dev = self.plib.run_ndctl_list_val(namespaces[0], 'blockdev') self.log_test = "/dev/%s" % log_dev log_dev = self.plib.run_ndctl_list_val(namespaces[1], 'blockdev') self.log_scratch = "/dev/%s" % log_dev else: self.plib.destroy_namespace(region=self.region, force=True) dev_size = self.get_half_region_size(self.region) self.log_test = None self.log_scratch = None self.plib.create_namespace(region=self.region, size=dev_size) self.plib.create_namespace(region=self.region, size=dev_size) namespaces = self.plib.run_ndctl_list('-N -r %s -m fsdax' % self.region) pmem_dev = self.plib.run_ndctl_list_val(namespaces[0], 'blockdev') self.test_dev = "/dev/%s" % pmem_dev pmem_dev = self.plib.run_ndctl_list_val(namespaces[1], 'blockdev') self.scratch_dev = "/dev/%s" % pmem_dev self.devices.extend([self.test_dev, self.scratch_dev])
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' ]) 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")
def test_no_binaries(self): with unittest.mock.patch('avocado.utils.path.find_command', return_value=False): with self.assertRaises(pmem.PMemException): pmem.PMem()
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') location = self.params.get('location', default='.') ndctl_project_version = self.params.get('ndctl_project_version', default='') url = "https://github.com/pmem/ndctl.git" if self.dist.name not in ['SuSE', 'rhel']: self.cancel('Unsupported OS %s' % self.dist.name) # DAX wont work with reflink, disabling here self.reflink = '-m reflink=0' self.smm = SoftwareManager() if self.package == 'upstream': deps.extend(['gcc', 'make', 'automake', 'autoconf']) if self.dist.name == 'SuSE': deps.extend([ 'libtool', 'libkmod-devel', 'libudev-devel', 'systemd-devel', 'libuuid-devel-static', 'libjson-c-devel', 'keyutils-devel', 'kmod-bash-completion', 'bash-completion-devel' ]) elif self.dist.name == 'rhel': deps.extend([ 'libtool', 'bash-completion', 'parted', 'kmod-devel', 'libuuid-devel', 'json-c-devel', 'systemd-devel', 'keyutils-libs-devel', 'jq' ]) for pkg in deps: if not self.smm.check_installed(pkg) and not \ self.smm.install(pkg): self.cancel('%s is needed for the test to be run' % pkg) if ndctl_project_version: ndctl_tag_name = "v" + ndctl_project_version # Clone the 'main' branch git.get_repo(url, branch='main', destination_dir=self.teststmpdir) os.chdir(self.teststmpdir) # Checkout the desired tag git_helper = GitRepoHelper(url, destination_dir=self.teststmpdir) git_helper.checkout(branch=ndctl_tag_name, commit=None) if (float(ndctl_project_version) < 73): self.autotools_build_system() else: self.meson_build_system(deps) # default to the meson way of building ndctl library else: # Clone the 'pending' branch git_branch = self.params.get('git_branch', default='pending') git.get_repo(url, branch=git_branch, destination_dir=self.teststmpdir) os.chdir(self.teststmpdir) self.meson_build_system(deps) elif self.package == 'local': self.ndctl = os.path.abspath(os.path.join(location, 'ndctl/ndctl')) self.daxctl = os.path.abspath( os.path.join(location, '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")
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 self.dev_type = self.params.get('type', default='loop') sm = SoftwareManager() self.detected_distro = distro.detect() packages = [ 'e2fsprogs', 'automake', 'gcc', 'quota', 'attr', 'make', 'xfsprogs', 'gawk' ] if self.detected_distro.name in ['Ubuntu', 'debian']: packages.extend([ 'xfslibs-dev', 'uuid-dev', 'libuuid1', 'libattr1-dev', 'libacl1-dev', 'libgdbm-dev', 'uuid-runtime', 'libaio-dev', 'fio', 'dbench', 'libbtrfs-dev' ]) if self.detected_distro.version in ['14']: packages.extend(['libtool']) elif self.detected_distro.version in ['18', '20']: 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']: if self.dev_type == 'nvdimm': packages.extend(['ndctl', 'parted']) if self.detected_distro.name == 'rhel': packages.extend(['daxctl']) 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.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) elif self.dev_type == 'nvdimm': self.test_dev = self.params.get('disk_test', default=None) self.scratch_dev = self.params.get('disk_scratch', default=None) self.log_test = self.params.get('log_test', default='') self.log_scratch = self.params.get('log_scratch', default='') logflag = self.params.get('logdev', default=False) self.plib = pmem.PMem() regions = sorted(self.plib.run_ndctl_list('-R'), key=lambda i: i['size'], reverse=True) if not (self.test_dev and self.scratch_dev): if not regions: self.plib.enable_region() regions = sorted(self.plib.run_ndctl_list('-R'), key=lambda i: i['size'], reverse=True) region = self.plib.run_ndctl_list_val(regions[0], 'dev') if not self.plib.is_region_legacy(region): self.plib.destroy_namespace(region=region, force=True) self.plib.create_namespace(region=region, size='21G', sector_size='512') pmem_dev = self.plib.run_ndctl_list_val( self.plib.run_ndctl_list('-N -r %s' % region)[0], 'blockdev') if logflag: if not (self.log_test and self.log_scratch): self.plib.create_namespace(region=region, size='3G', mode='sector', sector_size='512') log_dev = self.plib.run_ndctl_list_val( self.plib.run_ndctl_list('-N -r %s -m sector' % region)[0], 'blockdev') else: self.plib.enable_region() if not len(regions) > 1 and logflag: self.cancel("Cannot use logdev with one region") else: reg_2 = self.plib.run_ndctl_list_val(regions[1], 'dev') self.plib.create_namespace(region=reg_2, size='3G', mode='sector', sector_size='512') log_dev = self.plib.run_ndctl_list_val( self.plib.run_ndctl_list(' -N -r %s -m sector' % reg_2)[0], 'blockdev') pmem_dev = self.plib.run_ndctl_list_val( self.plib.run_ndctl_list('-N -r %s' % region)[0], 'blockdev') if process.system('parted -s -a optimal /dev/%s mklabel gpt --' ' mkpart primary xfs 1MiB 10GiB mkpart ' 'primary xfs 10GiB 20GiB' % pmem_dev, shell=True): self.cancel("Failed to setup PMEM partitions") self.test_dev = "/dev/%sp1" % pmem_dev self.scratch_dev = "/dev/%sp2" % pmem_dev self.devices.extend([self.test_dev, self.scratch_dev]) if logflag and not (self.log_test and self.log_scratch): if process.system('parted -s -a optimal /dev/%s mklabel gpt --' ' mkpart primary xfs 1MiB 1GiB mkpart ' 'primary xfs 1GiB 2GiB' % log_dev, shell=True): self.cancel("Failed to setup logdev partitions") self.log_test = "/dev/%s1" % log_dev self.log_scratch = "/dev/%s2" % log_dev 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='') 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 USE_EXTERNAL=yes\n') 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': if process.system('useradd 123456-fsgqa', sudo=True, ignore_status=True): self.log.warn('useradd 123456-fsgqa failed') if process.system('useradd fsgqa', sudo=True, ignore_status=True): self.log.warn('useradd fsgqa failed') else: if process.system('useradd -m -U fsgqa', sudo=True, ignore_status=True): self.log.warn('useradd fsgqa failed') if process.system('groupadd sys', sudo=True, ignore_status=True): self.log.warn('groupadd sys failed') 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)