From: Vincent Fu <vincent.fu@xxxxxxxxxxx>
The script contains three sets of tests. The first set of tests
exercises fio's decision making about checking the verify header's
sequence number and random seed. The second set of tests are aimed at
making sure that the checksum functions can detect data mismatches. The
final set of tests exercise fio's verify-related options such as
verify_backlog and verify_inteval.
This test script includes two checksum lists. The first list (default)
contains a subset of the checksum methods offered by fio, whereas the
second list contains the full set of checksum methods. The second, full
set can be run by specifying -c or --complete. Testing all of the
checksum methods can take a long time.
Signed-off-by: Vincent Fu <vincent.fu@xxxxxxxxxxx>
Signed-off-by: Ankit Kumar <ankit.kumar@xxxxxxxxxxx>
---
t/verify.py | 799 ++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 799 insertions(+)
create mode 100755 t/verify.py
diff --git a/t/verify.py b/t/verify.py
new file mode 100755
index 00000000..38c07bd1
--- /dev/null
+++ b/t/verify.py
@@ -0,0 +1,799 @@
+#!/usr/bin/env python3
+"""
+# verify.py
+#
+# Test fio's verify options.
+#
+# USAGE
+# see python3 verify.py --help
+#
+# EXAMPLES
+# python3 t/verify.py
+# python3 t/verify.py --fio ./fio
+#
+# REQUIREMENTS
+# Python 3.6
+# - 4 CPUs
+#
+"""
+import os
+import sys
+import time
+import errno
+import logging
+import argparse
+import platform
+import itertools
+from pathlib import Path
+from fiotestlib import FioJobCmdTest, run_fio_tests
+from fiotestcommon import SUCCESS_DEFAULT, SUCCESS_NONZERO, Requirements
+
+
+VERIFY_OPT_LIST = [
+ 'direct',
+ 'iodepth',
+ 'filesize',
+ 'bs',
+ 'time_based',
+ 'runtime',
+ 'io_size',
+ 'offset',
+ 'number_ios',
+ 'output-format',
+ 'directory',
+ 'norandommap',
+ 'numjobs',
+ 'nrfiles',
+ 'openfiles',
+ 'cpus_allowed',
+ 'experimental_verify',
+ 'verify_backlog',
+ 'verify_backlog_batch',
+ 'verify_interval',
+ 'verify_offset',
+ 'verify_async',
+ 'verify_async_cpus',
+ 'verify_pattern',
+ 'verify_only',
+]
+
+class VerifyTest(FioJobCmdTest):
+ """
+ Verify test class.
+ """
+
+ def setup(self, parameters):
+ """Setup a test."""
+
+ fio_args = [
+ "--name=verify",
+ f"--ioengine={self.fio_opts['ioengine']}",
+ f"--rw={self.fio_opts['rw']}",
+ f"--verify={self.fio_opts['verify']}",
+ f"--output={self.filenames['output']}",
+ ]
+ for opt in VERIFY_OPT_LIST:
+ if opt in self.fio_opts:
+ option = f"--{opt}={self.fio_opts[opt]}"
+ fio_args.append(option)
+
+ super().setup(fio_args)
+
+
+class VerifyCSUMTest(FioJobCmdTest):
+ """
+ Verify test class. Run standard verify jobs, modify the data, and then run
+ more verify jobs. Hopefully fio will detect that the data has chagned.
+ """
+
+ @staticmethod
+ def add_verify_opts(opt_list, adds):
+ """Add optional options."""
+
+ fio_opts = []
+
+ for opt in adds:
+ if opt in opt_list:
+ option = f"--{opt}={opt_list[opt]}"
+ fio_opts.append(option)
+
+ return fio_opts
+
+ def setup(self, parameters):
+ """Setup a test."""
+
+ logging.debug("ioengine is %s", self.fio_opts['ioengine'])
+ fio_args_base = [
+ "--filename=verify",
+ "--stonewall",
+ f"--ioengine={self.fio_opts['ioengine']}",
+ ]
+
+ extra_options = self.add_verify_opts(self.fio_opts, VERIFY_OPT_LIST)
+
+ verify_only = [
+ "--verify_only",
+ f"--rw={self.fio_opts['rw']}",
+ f"--verify={self.fio_opts['verify']}",
+ ] + fio_args_base + extra_options
+
+ verify_read = [
+ "--rw=randread" if 'rand' in self.fio_opts['rw'] else "--rw=read",
+ f"--verify={self.fio_opts['verify']}",
+ ] + fio_args_base + extra_options
+
+ layout = [
+ "--name=layout",
+ f"--rw={self.fio_opts['rw']}",
+ f"--verify={self.fio_opts['verify']}",
+ ] + fio_args_base + extra_options
+
+ success_only = ["--name=success_only"] + verify_only
+ success_read = ["--name=success_read"] + verify_read
+
+ mangle = [
+ "--name=mangle",
+ "--rw=randwrite",
+ "--randrepeat=0",
+ f"--bs={self.fio_opts['mangle_bs']}",
+ "--number_ios=1",
+ ] + fio_args_base + self.add_verify_opts(self.fio_opts, ['filesize'])
+
+ failure_only = ["--name=failure_only"] + verify_only
+ failure_read = ["--name=failure_read"] + verify_read
+
+ fio_args = layout + success_only + success_read + mangle + failure_only + failure_read + [f"--output={self.filenames['output']}"]
+ logging.debug("fio_args: %s", fio_args)
+
+ super().setup(fio_args)
+
+ def check_result(self):
+ super().check_result()
+
+ checked = {}
+
+ for job in self.json_data['jobs']:
+ if job['jobname'] == 'layout':
+ checked[job['jobname']] = True
+ if job['error']:
+ self.passed = False
+ self.failure_reason += " layout job failed"
+ elif 'success' in job['jobname']:
+ checked[job['jobname']] = True
+ if job['error']:
+ self.passed = False
+ self.failure_reason += f" verify pass {job['jobname']} that should have succeeded actually failed"
+ elif job['jobname'] == 'mangle':
+ checked[job['jobname']] = True
+ if job['error']:
+ self.passed = False
+ self.failure_reason += " mangle job failed"
+ elif 'failure' in job['jobname']:
+ checked[job['jobname']] = True
+ if self.fio_opts['verify'] == 'null' and not job['error']:
+ continue
+ if job['error'] != errno.EILSEQ:
+ self.passed = False
+ self.failure_reason += f" verify job {job['jobname']} produced {job['error']} instead of errno {errno.EILSEQ} Illegal byte sequence"
+ logging.debug(self.json_data)
+ else:
+ self.passed = False
+ self.failure_reason += " unknown job name"
+
+ if len(checked) != 6:
+ self.passed = False
+ self.failure_reason += " six phases not completed"
+
+ with open(self.filenames['stderr'], "r") as se:
+ contents = se.read()
+ logging.debug("stderr: %s", contents)
+
+
+#
+# These tests exercise fio's decisions about verifying the sequence number and
+# random seed in the verify header.
+#
+TEST_LIST_HEADER = [
+ {
+ # Basic test with options at default values
+ "test_id": 2000,
+ "fio_opts": {
+ "ioengine": "libaio",
+ "filesize": "1M",
+ "bs": 4096,
+ "output-format": "json",
+ },
+ "test_class": VerifyTest,
+ "success": SUCCESS_DEFAULT,
+ },
+ {
+ # Basic test with iodepth 16
+ "test_id": 2001,
+ "fio_opts": {
+ "ioengine": "libaio",
+ "filesize": "1M",
+ "bs": 4096,
+ "iodepth": 16,
+ "output-format": "json",
+ },
+ "test_class": VerifyTest,
+ "success": SUCCESS_DEFAULT,
+ },
+ {
+ # Basic test with 3 files
+ "test_id": 2002,
+ "fio_opts": {
+ "ioengine": "libaio",
+ "filesize": "1M",
+ "bs": 4096,
+ "nrfiles": 3,
+ "output-format": "json",
+ },
+ "test_class": VerifyTest,
+ "success": SUCCESS_DEFAULT,
+ },
+ {
+ # Basic test with iodepth 16 and 3 files
+ "test_id": 2003,
+ "fio_opts": {
+ "ioengine": "libaio",
+ "filesize": "1M",
+ "bs": 4096,
+ "iodepth": 16,
+ "nrfiles": 3,
+ "output-format": "json",
+ },
+ "test_class": VerifyTest,
+ "success": SUCCESS_DEFAULT,
+ },
+]
+
+#
+# These tests are mainly intended to assess the checksum functions. They write
+# out data, run some verify jobs, then modify the data, and try to verify the
+# data again, expecting to see failures.
+#
+TEST_LIST_CSUM = [
+ {
+ # basic seq write verify job
+ "test_id": 1000,
+ "fio_opts": {
+ "ioengine": "psync",
+ "filesize": "1M",
+ "bs": 4096,
+ "rw": "write",
+ "output-format": "json",
+ },
+ "test_class": VerifyCSUMTest,
+ "success": SUCCESS_NONZERO,
+ },
+ {
+ # basic rand write verify job
+ "test_id": 1001,
+ "fio_opts": {
+ "ioengine": "psync",
+ "filesize": "1M",
+ "bs": 4096,
+ "rw": "randwrite",
+ "output-format": "json",
+ },
+ "test_class": VerifyCSUMTest,
+ "success": SUCCESS_NONZERO,
+ },
+ {
+ # basic libaio seq write test
+ "test_id": 1002,
+ "fio_opts": {
+ "direct": 1,
+ "ioengine": "libaio",
+ "iodepth": 16,
+ "filesize": "1M",
+ "bs": 4096,
+ "rw": "write",
+ "output-format": "json",
+ },
+ "test_class": VerifyCSUMTest,
+ "success": SUCCESS_NONZERO,
+ },
+ {
+ # basic libaio rand write test
+ "test_id": 1003,
+ "fio_opts": {
+ "direct": 1,
+ "ioengine": "libaio",
+ "iodepth": 16,
+ "filesize": "1M",
+ "bs": 4096,
+ "rw": "randwrite",
+ "output-format": "json",
+ },
+ "test_class": VerifyCSUMTest,
+ "success": SUCCESS_NONZERO,
+ },
+]
+
+#
+# These tests are run for all combinations of data direction and checksum
+# methods.
+#
+TEST_LIST = [
+ {
+ # norandommap with verify backlog
+ "test_id": 1,
+ "fio_opts": {
+ "direct": 1,
+ "ioengine": "libaio",
+ "iodepth": 32,
+ "filesize": "2M",
+ "norandommap": 1,
+ "bs": 512,
+ "time_based": 1,
+ "runtime": 3,
+ "verify_backlog": 128,
+ "verify_backlog_batch": 64,
+ },
+ "test_class": VerifyTest,
+ },
+ {
+ # norandommap with verify offset and interval
+ "test_id": 2,
+ "fio_opts": {
+ "direct": 1,
+ "ioengine": "libaio",
+ "iodepth": 32,
+ "filesize": "2M",
+ "io_size": "4M",
+ "norandommap": 1,
+ "bs": 4096,
+ "verify_interval": 2048,
+ "verify_offset": 1024,
+ },
+ "test_class": VerifyTest,
+ },
+ {
+ # norandommap with verify offload to async threads
+ "test_id": 3,
+ "fio_opts": {
+ "direct": 1,
+ "ioengine": "libaio",
+ "iodepth": 32,
+ "filesize": "2M",
+ "norandommap": 1,
+ "bs": 4096,
+ "cpus_allowed": "0-3",
+ "verify_async": 2,
+ "verify_async_cpus": "0-1",
+ },
+ "test_class": VerifyTest,
+ "requirements": [Requirements.not_macos,
+ Requirements.cpucount4],
+ # mac os does not support CPU affinity
+ },
+ {
+ # tausworthe combine all verify options
+ "test_id": 4,
+ "fio_opts": {
+ "direct": 1,
+ "ioengine": "libaio",
+ "iodepth": 32,
+ "filesize": "4M",
+ "bs": 4096,
+ "cpus_allowed": "0-3",
+ "time_based": 1,
+ "random_generator": "tausworthe",
+ "runtime": 3,
+ "verify_interval": 2048,
+ "verify_offset": 1024,
+ "verify_backlog": 128,
+ "verify_backlog_batch": 128,
+ "verify_async": 2,
+ "verify_async_cpus": "0-1",
+ },
+ "test_class": VerifyTest,
+ "requirements": [Requirements.not_macos,
+ Requirements.cpucount4],
+ # mac os does not support CPU affinity
+ },
+ {
+ # norandommap combine all verify options
+ "test_id": 5,
+ "fio_opts": {
+ "direct": 1,
+ "ioengine": "libaio",
+ "iodepth": 32,
+ "filesize": "4M",
+ "norandommap": 1,
+ "bs": 4096,
+ "cpus_allowed": "0-3",
+ "time_based": 1,
+ "runtime": 3,
+ "verify_interval": 2048,
+ "verify_offset": 1024,
+ "verify_backlog": 128,
+ "verify_backlog_batch": 128,
+ "verify_async": 2,
+ "verify_async_cpus": "0-1",
+ },
+ "test_class": VerifyTest,
+ "requirements": [Requirements.not_macos,
+ Requirements.cpucount4],
+ # mac os does not support CPU affinity
+ },
+ {
+ # multiple jobs and files with verify
+ "test_id": 6,
+ "fio_opts": {
+ "direct": 1,
+ "ioengine": "libaio",
+ "iodepth": 32,
+ "filesize": "512K",
+ "nrfiles": 3,
+ "openfiles": 2,
+ "numjobs": 2,
+ "norandommap": 1,
+ "bs": 4096,
+ "time_based": 1,
+ "runtime": 20,
+ "verify_interval": 2048,
+ "verify_offset": 1024,
+ "verify_backlog": 16,
+ "verify_backlog_batch": 16,
+ },
+ "test_class": VerifyTest,
+ },
+]
+
+
+def parse_args():
+ """Parse command-line arguments."""
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument('-r', '--fio-root', help='fio root path')
+ parser.add_argument('-d', '--debug', help='Enable debug messages', action='store_true')
+ parser.add_argument('-f', '--fio', help='path to file executable (e.g., ./fio)')
+ parser.add_argument('-a', '--artifact-root', help='artifact root directory')
+ parser.add_argument('-c', '--complete', help='Enable all checksums', action='store_true')
+ parser.add_argument('-s', '--skip', nargs='+', type=int,
+ help='list of test(s) to skip')
+ parser.add_argument('-o', '--run-only', nargs='+', type=int,
+ help='list of test(s) to run, skipping all others')
+ parser.add_argument('-k', '--skip-req', action='store_true',
+ help='skip requirements checking')
+ parser.add_argument('--csum', nargs='+', type=str,
+ help='list of checksum methods to use, skipping all others')
+ args = parser.parse_args()
+
+ return args
+
+
+def verify_test_header(test_env, args, csum, mode, sequence):
+ """
+ Adjust test arguments based on values of mode and sequence. Then run the
+ tests. This function is intended to run a set of tests that test
+ conditions under which the header random seed and sequence number are
+ checked.
+
+ The result should be a matrix with these combinations:
+ {write, write w/verify_only, read/write, read/write w/verify_only, read} x
+ {sequential, random w/randommap, random w/norandommap, sequence modifiers}
+ """
+ for test in TEST_LIST_HEADER:
+ # experimental_verify does not work in verify_only=1 mode
+ if "_vo" in mode and 'experimental_verify' in test['fio_opts'] and \
+ test['fio_opts']['experimental_verify']:
+ test['force_skip'] = True
+ else:
+ test['force_skip'] = False
+
+ test['fio_opts']['verify'] = csum
+ if csum == 'pattern':
+ test['fio_opts']['verify_pattern'] = '"abcd"-120xdeadface'
+ else:
+ test['fio_opts'].pop('verify_pattern', None)
+
+ if 'norandommap' in sequence:
+ test['fio_opts']['norandommap'] = 1
+ else:
+ test['fio_opts']['norandommap'] = 0
+
+ if 'randommap' in sequence:
+ prefix = "rand"
+ else:
+ prefix = ""
+
+ if 'sequence_modifier' in sequence:
+ suffix = ":4096"
+ else:
+ suffix = ""
+
+ if 'readwrite' in mode:
+ fio_ddir = 'rw'
+ elif 'write' in mode:
+ fio_ddir = 'write'
+ elif 'read' in mode:
+ fio_ddir = 'read'
+ else:
+ fio_ddir = ""
+ # TODO throw an exception here
+ test['fio_opts']['rw'] = prefix + fio_ddir + suffix
+ logging.debug("ddir is %s", test['fio_opts']['rw'])
+
+ if '_vo' in mode:
+ vo = 1
+ else:
+ vo = 0
+ test['fio_opts']['verify_only'] = vo
+
+ # For 100% read workloads we need to read a file that was written with
+ # verify enabled. Use a previous test case for this by pointing fio to
+ # write to a file in a specific directory.
+ #
+ # For verify_only tests we also need to point fio to a file that was
+ # written with verify enabled
+ #
+ # Finally, we have observed on Windows platforms that fio may not
+ # create files of the size specified by filesize. This causes false
+ # positive test failures when we later try to run 100% read verify jobs
+ # on the files as the verify job may lay out a file of the size
+ # specified by filesize and overwrite the previously written file,
+ # inducing verificaiton failures. Until this issue is resolved, just
+ # skip these tests on Windows.
+ # https://github.com/axboe/fio/issues/1872
+ if mode == 'read':
+ directory = os.path.join(test_env['artifact_root'].replace(f'mode_{mode}','mode_write'),
+ f"{test['test_id']:04d}")
+ test['fio_opts']['directory'] = str(Path(directory).absolute()) if \
+ platform.system() != "Windows" else str(Path(directory).absolute()).replace(':', '\\:')
+ if platform.system() == "Windows":
+ test['force_skip'] = True
+ elif vo:
+ directory = os.path.join(test_env['artifact_root'].replace('write_vo','write'),
+ f"{test['test_id']:04d}")
+ test['fio_opts']['directory'] = str(Path(directory).absolute()) if \
+ platform.system() != "Windows" else str(Path(directory).absolute()).replace(':', '\\:')
+ if platform.system() == "Windows":
+ test['force_skip'] = True
+ else:
+ test['fio_opts'].pop('directory', None)
+
+ return run_fio_tests(TEST_LIST_HEADER, test_env, args)
+
+
+MANGLE_JOB_BS = 0
+def verify_test_csum(test_env, args, mbs, csum):
+ """
+ Adjust test arguments based on values of csum. Then run the tests.
+ This function is designed for a series of tests that check that checksum
+ methods can reliably detect data integrity issues.
+ """
+ for test in TEST_LIST_CSUM:
+ test['force_skip'] = False
+ test['fio_opts']['verify'] = csum
+
+ if csum == 'pattern':
+ test['fio_opts']['verify_pattern'] = '"abcd"-120xdeadface'
+ else:
+ test['fio_opts'].pop('verify_pattern', None)
+
+ if mbs == MANGLE_JOB_BS:
+ test['fio_opts']['mangle_bs'] = test['fio_opts']['bs']
+ else:
+ test['fio_opts']['mangle_bs'] = mbs
+
+ # These tests produce verification failures but not when verify=null,
+ # so adjust the success criterion.
+ if csum == 'null':
+ test['success'] = SUCCESS_DEFAULT
+ else:
+ test['success'] = SUCCESS_NONZERO
+
+ return run_fio_tests(TEST_LIST_CSUM, test_env, args)
+
+
+def verify_test(test_env, args, ddir, csum):
+ """
+ Adjust test arguments based on values of ddir and csum. Then run
+ the tests.
+ """
+ for test in TEST_LIST:
+ test['force_skip'] = False
+
+ test['fio_opts']['rw'] = ddir
+ test['fio_opts']['verify'] = csum
+
+ if csum == 'pattern':
+ test['fio_opts']['verify_pattern'] = '"abcd"-120xdeadface'
+ else:
+ test['fio_opts'].pop('verify_pattern', None)
+
+ # For 100% read data directions we need the write file that was written with
+ # verify enabled. Use a previous test case for this by telling fio to
+ # write to a file in a specific directory.
+ if ddir == 'read':
+ directory = os.path.join(test_env['artifact_root'].replace(f'ddir_{ddir}','ddir_write'),
+ f"{test['test_id']:04d}")
+ test['fio_opts']['directory'] = str(Path(directory).absolute()) if \
+ platform.system() != "Windows" else str(Path(directory).absolute()).replace(':', '\\:')
+ elif ddir == 'randread':
+ directory = os.path.join(test_env['artifact_root'].replace(f'ddir_{ddir}','ddir_randwrite'),
+ f"{test['test_id']:04d}")
+ test['fio_opts']['directory'] = str(Path(directory).absolute()) if \
+ platform.system() != "Windows" else str(Path(directory).absolute()).replace(':', '\\:')
+ else:
+ test['fio_opts'].pop('directory', None)
+
+ # On Windows we are skipping the tests below because of the filesize
+ # issue noted above.
+ if ddir in [ 'read', 'randread' ] and platform.system() == 'Windows':
+ test['force_skip'] = True
+
+ return run_fio_tests(TEST_LIST, test_env, args)
+
+
+# 100% read workloads below must follow write workloads so that the 100% read
+# workloads will be reading data written with verification enabled.
+DDIR_LIST = [
+ 'write',
+ 'readwrite',
+ 'read',
+ 'randwrite',
+ 'randrw',
+ 'randread',
+ ]
+CSUM_LIST1 = [
+ 'md5',
+ 'crc64',
+ 'pattern',
+ ]
+CSUM_LIST2 = [
+ 'md5',
+ 'crc64',
+ 'crc32c',
+ 'crc32c-intel',
+ 'crc16',
+ 'crc7',
+ 'xxhash',
+ 'sha512',
+ 'sha256',
+ 'sha1',
+ 'sha3-224',
+ 'sha3-384',
+ 'sha3-512',
+ 'pattern',
+ 'null',
+ ]
+
+def main():
+ """
+ Run tests for fio's verify feature.
+ """
+
+ args = parse_args()
+
+ if args.debug:
+ logging.basicConfig(level=logging.DEBUG)
+ else:
+ logging.basicConfig(level=logging.INFO)
+
+ artifact_root = args.artifact_root if args.artifact_root else \
+ f"verify-test-{time.strftime('%Y%m%d-%H%M%S')}"
+ os.mkdir(artifact_root)
+ print(f"Artifact directory is {artifact_root}")
+
+ if args.fio:
+ fio_path = str(Path(args.fio).absolute())
+ else:
+ fio_path = os.path.join(os.path.dirname(__file__), '../fio')
+ print(f"fio path is {fio_path}")
+
+ if args.fio_root:
+ fio_root = args.fio_root
+ else:
+ fio_root = str(Path(__file__).absolute().parent.parent)
+ print(f"fio root is {fio_root}")
+
+ if not args.skip_req:
+ Requirements(fio_root, args)
+
+ test_env = {
+ 'fio_path': fio_path,
+ 'fio_root': str(Path(__file__).absolute().parent.parent),
+ 'artifact_root': artifact_root,
+ 'basename': 'verify',
+ }
+
+ if platform.system() == 'Linux':
+ aio = 'libaio'
+ sync = 'psync'
+ elif platform.system() == 'Windows':
+ aio = 'windowsaio'
+ sync = 'sync'
+ else:
+ aio = 'posixaio'
+ sync = 'psync'
+ for test in TEST_LIST:
+ if 'aio' in test['fio_opts']['ioengine']:
+ test['fio_opts']['ioengine'] = aio
+ if 'sync' in test['fio_opts']['ioengine']:
+ test['fio_opts']['ioengine'] = sync
+ for test in TEST_LIST_CSUM:
+ if 'aio' in test['fio_opts']['ioengine']:
+ test['fio_opts']['ioengine'] = aio
+ if 'sync' in test['fio_opts']['ioengine']:
+ test['fio_opts']['ioengine'] = sync
+ for test in TEST_LIST_HEADER:
+ if 'aio' in test['fio_opts']['ioengine']:
+ test['fio_opts']['ioengine'] = aio
+ if 'sync' in test['fio_opts']['ioengine']:
+ test['fio_opts']['ioengine'] = sync
+
+ total = { 'passed': 0, 'failed': 0, 'skipped': 0 }
+
+ if args.complete:
+ csum_list = CSUM_LIST2
+ else:
+ csum_list = CSUM_LIST1
+
+ if args.csum:
+ csum_list = args.csum
+
+ try:
+ for ddir, csum in itertools.product(DDIR_LIST, csum_list):
+ print(f"\nddir: {ddir}, checksum: {csum}")
+
+ test_env['artifact_root'] = os.path.join(artifact_root,
+ f"ddir_{ddir}_csum_{csum}")
+ os.mkdir(test_env['artifact_root'])
+
+ passed, failed, skipped = verify_test(test_env, args, ddir, csum)
+
+ total['passed'] += passed
+ total['failed'] += failed
+ total['skipped'] += skipped
+
+ # MANGLE_JOB_BS means to mangle an entire block which should result in
+ # a header magic number error
+ # 4 means to mangle 4 bytes which should result in a checksum error
+ # unless the 4 bytes occur in the verification header
+ mangle_bs = [MANGLE_JOB_BS, 4]
+ for mbs, csum in itertools.product(mangle_bs, csum_list):
+ print(f"\nmangle block size: {mbs}, checksum: {csum}")
+
+ test_env['artifact_root'] = os.path.join(artifact_root,
+ f"mbs_{mbs}_csum_{csum}")
+ os.mkdir(test_env['artifact_root'])
+
+ passed, failed, skipped = verify_test_csum(test_env, args, mbs, csum)
+
+ total['passed'] += passed
+ total['failed'] += failed
+ total['skipped'] += skipped
+
+ # The loop below tests combinations of options that exercise fio's
+ # decisions about disabling checks for the sequence number and random
+ # seed in the verify header.
+ mode_list = [ "write", "write_vo", "readwrite", "readwrite_vo", "read" ]
+ sequence_list = [ "sequential", "randommap", "norandommap", "sequence_modifier" ]
+ for mode, sequence in itertools.product(mode_list, sequence_list):
+ print(f"\nmode: {mode}, sequence: {sequence}")
+
+ test_env['artifact_root'] = os.path.join(artifact_root,
+ f"mode_{mode}_seq_{sequence}")
+ os.mkdir(test_env['artifact_root'])
+
+ passed, failed, skipped = verify_test_header(test_env, args, 'md5', mode, sequence)
+
+ total['passed'] += passed
+ total['failed'] += failed
+ total['skipped'] += skipped
+
+ except KeyboardInterrupt:
+ pass
+
+ print(f"\n\n{total['passed']} test(s) passed, {total['failed']} failed, " \
+ f"{total['skipped']} skipped")
+ sys.exit(total['failed'])
+
+
+if __name__ == '__main__':
+ main()
--
2.25.1
