diff --git a/tests/zfs-tests/tests/perf/perf.shlib b/tests/zfs-tests/tests/perf/perf.shlib
index 6f4fdc94348f..5a404df083e4 100644
--- a/tests/zfs-tests/tests/perf/perf.shlib
+++ b/tests/zfs-tests/tests/perf/perf.shlib
@@ -1,602 +1,601 @@
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2015, 2021 by Delphix. All rights reserved.
 # Copyright (c) 2016, Intel Corporation.
 #
 
 . $STF_SUITE/include/libtest.shlib
 
 # Defaults common to all the tests in the regression group
 export PERF_RUNTIME=${PERF_RUNTIME:-'180'}
 export PERF_RANDSEED=${PERF_RANDSEED:-'1234'}
 export PERF_COMPPERCENT=${PERF_COMPPERCENT:-'66'}
 export PERF_COMPCHUNK=${PERF_COMPCHUNK:-'4096'}
-export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'1'}
 
 # Default to JSON for fio output
 export PERF_FIO_FORMAT=${PERF_FIO_FORMAT:-'json'}
 
 # Default fs creation options
 export PERF_FS_OPTS=${PERF_FS_OPTS:-'-o recsize=8k -o compress=lz4' \
     ' -o checksum=sha256 -o redundant_metadata=most'}
 
 function get_sync_str
 {
 	typeset sync=$1
 	typeset sync_str=''
 
 	[[ $sync -eq 0 ]] && sync_str='async'
 	[[ $sync -eq 1 ]] && sync_str='sync'
 	echo $sync_str
 }
 
 function get_suffix
 {
 	typeset threads=$1
 	typeset sync=$2
 	typeset iosize=$3
 
 	typeset sync_str=$(get_sync_str $sync)
 	typeset filesystems=$(get_nfilesystems)
 
 	typeset suffix="$sync_str.$iosize-ios"
 	suffix="$suffix.$threads-threads.$filesystems-filesystems"
 	echo $suffix
 }
 
 function do_fio_run_impl
 {
 	typeset script=$1
 	typeset do_recreate=$2
 	typeset clear_cache=$3
 
 	typeset threads=$4
 	typeset threads_per_fs=$5
 	typeset sync=$6
 	typeset iosize=$7
 
 	typeset sync_str=$(get_sync_str $sync)
 	log_note "Running with $threads $sync_str threads, $iosize ios"
 
 	if [[ -n $threads_per_fs && $threads_per_fs -ne 0 ]]; then
 		log_must test $do_recreate
 		verify_threads_per_fs $threads $threads_per_fs
 	fi
 
 	if $do_recreate; then
 		recreate_perf_pool
 
 		#
 		# A value of zero for "threads_per_fs" is "special", and
 		# means a single filesystem should be used, regardless
 		# of the number of threads.
 		#
 		if [[ -n $threads_per_fs && $threads_per_fs -ne 0 ]]; then
 			populate_perf_filesystems $((threads / threads_per_fs))
 		else
 			populate_perf_filesystems 1
 		fi
 	fi
 
 	if $clear_cache; then
 		# Clear the ARC
 		log_must zinject -a
 	fi
 
 	if [[ -n $ZINJECT_DELAYS ]]; then
 		apply_zinject_delays
 	else
 		log_note "No per-device commands to execute."
 	fi
 
 	#
 	# Allow this to be overridden by the individual test case. This
 	# can be used to run the FIO job against something other than
 	# the default filesystem (e.g. against a clone).
 	#
 	export DIRECTORY=$(get_directory)
 	log_note "DIRECTORY: " $DIRECTORY
 
 	export RUNTIME=$PERF_RUNTIME
 	export RANDSEED=$PERF_RANDSEED
 	export COMPPERCENT=$PERF_COMPPERCENT
 	export COMPCHUNK=$PERF_COMPCHUNK
 	export FILESIZE=$((TOTAL_SIZE / threads))
 	export NUMJOBS=$threads
 	export SYNC_TYPE=$sync
 	export BLOCKSIZE=$iosize
 	sync
 
 	# When running locally, we want to keep the default behavior of
 	# DIRECT == 0, so only set it when we're running over NFS to
 	# disable client cache for reads.
 	if [[ $NFS -eq 1 ]]; then
 		export DIRECT=1
 		do_setup_nfs $script
 	else
 		export DIRECT=0
 	fi
 
 	# This will be part of the output filename.
 	typeset suffix=$(get_suffix $threads $sync $iosize)
 
 	# Start the data collection
 	do_collect_scripts $suffix
 
 	# Define output file
 	typeset logbase="$(get_perf_output_dir)/$(basename \
 	    $SUDO_COMMAND)"
 	typeset outfile="$logbase.fio.$suffix"
 
 	# Start the load
 	if [[ $NFS -eq 1 ]]; then
 		log_must ssh -t $NFS_USER@$NFS_CLIENT "
 			fio --output-format=${PERF_FIO_FORMAT} \
 			    --output /tmp/fio.out /tmp/test.fio
 		"
 		log_must scp $NFS_USER@$NFS_CLIENT:/tmp/fio.out $outfile
 		log_must ssh -t $NFS_USER@$NFS_CLIENT "sudo -S umount $NFS_MOUNT"
 	else
 		log_must fio --output-format=${PERF_FIO_FORMAT} \
 		    --output $outfile $FIO_SCRIPTS/$script
 	fi
 }
 
 #
 # This function will run fio in a loop, according to the .fio file passed
 # in and a number of environment variables. The following variables can be
 # set before launching zfstest to override the defaults.
 #
 # PERF_RUNTIME: The time in seconds each fio invocation should run.
 # PERF_NTHREADS: A list of how many threads each fio invocation will use.
 # PERF_SYNC_TYPES: Whether to use (O_SYNC) or not. 1 is sync IO, 0 is async IO.
 # PERF_IOSIZES: A list of blocksizes in which each fio invocation will do IO.
 # PERF_COLLECT_SCRIPTS: A comma delimited list of 'command args, logfile_tag'
 #    pairs that will be added to the scripts specified in each test.
 #
 function do_fio_run
 {
 	typeset script=$1
 	typeset do_recreate=$2
 	typeset clear_cache=$3
 	typeset threads threads_per_fs sync iosize
 
 	for threads in $PERF_NTHREADS; do
 		for threads_per_fs in $PERF_NTHREADS_PER_FS; do
 			for sync in $PERF_SYNC_TYPES; do
 				for iosize in $PERF_IOSIZES; do
 					do_fio_run_impl \
 					    $script \
 					    $do_recreate \
 					    $clear_cache \
 					    $threads \
 					    $threads_per_fs \
 					    $sync \
 					    $iosize
 				done
 			done
 		done
 	done
 }
 
 # This function sets NFS mount on the client and make sure all correct
 # permissions are in place
 #
 function do_setup_nfs
 {
 	typeset script=$1
 	zfs set sharenfs=on $TESTFS
 	log_must chmod  -R 777 /$TESTFS
 
 	ssh -t $NFS_USER@$NFS_CLIENT "mkdir -m 777 -p $NFS_MOUNT"
 	ssh -t $NFS_USER@$NFS_CLIENT "sudo -S umount $NFS_MOUNT"
 	log_must ssh -t $NFS_USER@$NFS_CLIENT "
 		sudo -S mount $NFS_OPTIONS $NFS_SERVER:/$TESTFS $NFS_MOUNT
 	"
 	#
 	# The variables in the fio script are only available in our current
 	# shell session, so we have to evaluate them here before copying
 	# the resulting script over to the target machine.
 	#
 	export jobnum='$jobnum'
 	while read line; do
 		eval echo "$line"
 	done < $FIO_SCRIPTS/$script > /tmp/test.fio
 	log_must sed -i -e "s%directory.*%directory=$NFS_MOUNT%" /tmp/test.fio
 	log_must scp /tmp/test.fio $NFS_USER@$NFS_CLIENT:/tmp
 	log_must rm /tmp/test.fio
 }
 
 #
 # This function iterates through the value pairs in $PERF_COLLECT_SCRIPTS.
 # The script at index N is launched in the background, with its output
 # redirected to a logfile containing the tag specified at index N + 1.
 #
 function do_collect_scripts
 {
 	typeset suffix=$1
 
 	[[ -n $collect_scripts ]] || log_fail "No data collection scripts."
 	[[ -n $PERF_RUNTIME ]] || log_fail "No runtime specified."
 
 	# Add in user supplied scripts and logfiles, if any.
 	typeset oIFS=$IFS
 	IFS=','
 	for item in $PERF_COLLECT_SCRIPTS; do
 		collect_scripts+=($(echo $item | sed 's/^ *//g'))
 	done
 	IFS=$oIFS
 
 	typeset idx=0
 	while [[ $idx -lt "${#collect_scripts[@]}" ]]; do
 		typeset logbase="$(get_perf_output_dir)/$(basename \
 		    $SUDO_COMMAND)"
 		typeset outfile="$logbase.${collect_scripts[$idx + 1]}.$suffix"
 
 		timeout $PERF_RUNTIME ${collect_scripts[$idx]} >$outfile 2>&1 &
 		((idx += 2))
 	done
 
 	# Need to explicitly return 0 because timeout(1) will kill
 	# a child process and cause us to return non-zero.
 	return 0
 }
 
 # Find a place to deposit performance data collected while under load.
 function get_perf_output_dir
 {
 	typeset dir="$(pwd)/perf_data"
 	[[ -d $dir ]] || mkdir -p $dir
 
 	echo $dir
 }
 
 function apply_zinject_delays
 {
 	typeset idx=0
 	while [[ $idx -lt "${#ZINJECT_DELAYS[@]}" ]]; do
 		[[ -n ${ZINJECT_DELAYS[$idx]} ]] || \
 		    log_must "No zinject delay found at index: $idx"
 
 		for disk in $DISKS; do
 			log_must zinject \
 			    -d $disk -D ${ZINJECT_DELAYS[$idx]} $PERFPOOL
 		done
 
 		((idx += 1))
 	done
 }
 
 function clear_zinject_delays
 {
 	log_must zinject -c all
 }
 
 #
 # Destroy and create the pool used for performance tests.
 #
 function recreate_perf_pool
 {
 	[[ -n $PERFPOOL ]] || log_fail "The \$PERFPOOL variable isn't set."
 
 	#
 	# In case there's been some "leaked" zinject delays, or if the
 	# performance test injected some delays itself, we clear all
 	# delays before attempting to destroy the pool. Each delay
 	# places a hold on the pool, so the destroy will fail if there
 	# are any outstanding delays.
 	#
 	clear_zinject_delays
 
 	#
 	# This function handles the case where the pool already exists,
 	# and will destroy the previous pool and recreate a new pool.
 	#
 	create_pool $PERFPOOL $DISKS
 }
 
 function verify_threads_per_fs
 {
 	typeset threads=$1
 	typeset threads_per_fs=$2
 
 	log_must test -n $threads
 	log_must test -n $threads_per_fs
 
 	#
 	# A value of "0" is treated as a "special value", and it is
 	# interpreted to mean all threads will run using a single
 	# filesystem.
 	#
 	[[ $threads_per_fs -eq 0 ]] && return
 
 	#
 	# The number of threads per filesystem must be a value greater
 	# than or equal to zero; since we just verified the value isn't
 	# 0 above, then it must be greater than zero here.
 	#
 	log_must test $threads_per_fs -ge 0
 
 	#
 	# This restriction can be lifted later if needed, but for now,
 	# we restrict the number of threads per filesystem to a value
 	# that evenly divides the thread count. This way, the threads
 	# will be evenly distributed over all the filesystems.
 	#
 	log_must test $((threads % threads_per_fs)) -eq 0
 }
 
 function populate_perf_filesystems
 {
 	typeset nfilesystems=${1:-1}
 
 	export TESTFS=""
 	for i in $(seq 1 $nfilesystems); do
 		typeset dataset="$PERFPOOL/fs$i"
 		create_dataset $dataset $PERF_FS_OPTS
 		if [[ -z "$TESTFS" ]]; then
 			TESTFS="$dataset"
 		else
 			TESTFS="$TESTFS $dataset"
 		fi
 	done
 }
 
 function get_nfilesystems
 {
 	typeset filesystems=( $TESTFS )
 	echo ${#filesystems[@]}
 }
 
 function get_directory
 {
 	typeset filesystems=( $TESTFS )
 	typeset directory=
 
 	typeset idx=0
 	while [[ $idx -lt "${#filesystems[@]}" ]]; do
 		mountpoint=$(get_prop mountpoint "${filesystems[$idx]}")
 
 		if [[ -n $directory ]]; then
 			directory=$directory:$mountpoint
 		else
 			directory=$mountpoint
 		fi
 
 		((idx += 1))
 	done
 
 	echo $directory
 }
 
 function get_min_arc_size
 {
 	typeset -l min_arc_size
 
 	if is_freebsd; then
 		min_arc_size=$(sysctl -n kstat.zfs.misc.arcstats.c_min)
 	elif is_illumos; then
 		min_arc_size=$(dtrace -qn 'BEGIN {
 		    printf("%u\n", `arc_stats.arcstat_c_min.value.ui64);
 		    exit(0);
 		}')
 	elif is_linux; then
 		min_arc_size=`awk '$1 == "c_min" { print $3 }' \
 		    /proc/spl/kstat/zfs/arcstats`
 	fi
 
 	[[ $? -eq 0 ]] || log_fail "get_min_arc_size failed"
 
 	echo $min_arc_size
 }
 
 function get_max_arc_size
 {
 	typeset -l max_arc_size
 
 	if is_freebsd; then
 		max_arc_size=$(sysctl -n kstat.zfs.misc.arcstats.c_max)
 	elif is_illumos; then
 		max_arc_size=$(dtrace -qn 'BEGIN {
 		    printf("%u\n", `arc_stats.arcstat_c_max.value.ui64);
 		    exit(0);
 		}')
 	elif is_linux; then
 		max_arc_size=`awk '$1 == "c_max" { print $3 }' \
 		    /proc/spl/kstat/zfs/arcstats`
 	fi
 
 	[[ $? -eq 0 ]] || log_fail "get_max_arc_size failed"
 
 	echo $max_arc_size
 }
 
 function get_arc_target
 {
 	typeset -l arc_c
 
 	if is_freebsd; then
 		arc_c=$(sysctl -n kstat.zfs.misc.arcstats.c)
 	elif is_illumos; then
 		arc_c=$(dtrace -qn 'BEGIN {
 		    printf("%u\n", `arc_stats.arcstat_c.value.ui64);
 		    exit(0);
 		}')
 	elif is_linux; then
 		arc_c=`awk '$1 == "c" { print $3 }' \
 		    /proc/spl/kstat/zfs/arcstats`
 	fi
 
 	[[ $? -eq 0 ]] || log_fail "get_arc_target failed"
 
 	echo $arc_c
 }
 
 function get_dbuf_cache_size
 {
 	typeset -l dbuf_cache_size dbuf_cache_shift
 
 	if is_illumos; then
 		dbuf_cache_size=$(dtrace -qn 'BEGIN {
 		    printf("%u\n", `dbuf_cache_max_bytes);
 		    exit(0);
 		}')
 	else
 		dbuf_cache_shift=$(get_tunable DBUF_CACHE_SHIFT)
 		dbuf_cache_size=$(($(get_arc_target) / 2**dbuf_cache_shift))
 	fi
 
 	[[ $? -eq 0 ]] || log_fail "get_dbuf_cache_size failed"
 
 	echo $dbuf_cache_size
 }
 
 # Create a file with some information about how this system is configured.
 function get_system_config
 {
 	typeset config=$PERF_DATA_DIR/$1
 
 	echo "{" >>$config
 	if is_linux; then
 		echo "  \"ncpus\": \"$(nproc --all)\"," >>$config
 		echo "  \"physmem\": \"$(free -b | \
 		    awk '$1 == "Mem:" { print $2 }')\"," >>$config
 		echo "  \"c_max\": \"$(get_max_arc_size)\"," >>$config
 		echo "  \"hostname\": \"$(uname -n)\"," >>$config
 		echo "  \"kernel version\": \"$(uname -sr)\"," >>$config
 	else
 		dtrace -qn 'BEGIN{
 		    printf("  \"ncpus\": %d,\n", `ncpus);
 		    printf("  \"physmem\": %u,\n", `physmem * `_pagesize);
 		    printf("  \"c_max\": %u,\n", `arc_stats.arcstat_c_max.value.ui64);
 		    printf("  \"kmem_flags\": \"0x%x\",", `kmem_flags);
 		    exit(0)}' >>$config
 		echo "  \"hostname\": \"$(uname -n)\"," >>$config
 		echo "  \"kernel version\": \"$(uname -v)\"," >>$config
 	fi
 	if is_linux; then
 		lsblk -dino NAME,SIZE | awk 'BEGIN {
 		    printf("  \"disks\": {\n"); first = 1}
 		    {disk = $1} {size = $2;
 		    if (first != 1) {printf(",\n")} else {first = 0}
 		    printf("    \"%s\": \"%s\"", disk, size)}
 		    END {printf("\n  },\n")}' >>$config
 
 		zfs_tunables="/sys/module/zfs/parameters"
 
 		printf "  \"tunables\": {\n" >>$config
 		for tunable in \
 		    zfs_arc_max \
 		    zfs_arc_meta_limit \
 		    zfs_arc_sys_free \
 		    zfs_dirty_data_max \
 		    zfs_flags \
 		    zfs_prefetch_disable \
 		    zfs_txg_timeout \
 		    zfs_vdev_aggregation_limit \
 		    zfs_vdev_async_read_max_active \
 		    zfs_vdev_async_write_max_active \
 		    zfs_vdev_sync_read_max_active \
 		    zfs_vdev_sync_write_max_active \
 		    zio_slow_io_ms
 		do
 			if [ "$tunable" != "zfs_arc_max" ]
 			then
 				printf ",\n" >>$config
 			fi
 			printf  "    \"$tunable\": \"$(<$zfs_tunables/$tunable)\"" \
 			    >>$config
 		done
 		printf "\n  }\n" >>$config
 	else
 		iostat -En | awk 'BEGIN {
 		    printf("  \"disks\": {\n"); first = 1}
 		    /^c/ {disk = $1}
 		    /^Size: [^0]/ {size = $2;
 		    if (first != 1) {printf(",\n")} else {first = 0}
 		    printf("    \"%s\": \"%s\"", disk, size)}
 		    END {printf("\n  },\n")}' >>$config
 
 		sed -n 's/^set \(.*\)[ ]=[ ]\(.*\)/\1=\2/p' /etc/system | \
 		    awk -F= 'BEGIN {printf("  \"system\": {\n"); first = 1}
 		    {if (first != 1) {printf(",\n")} else {first = 0};
 		    printf("    \"%s\": %s", $1, $2)}
 		    END {printf("\n  }\n")}' >>$config
 	fi
 	echo "}" >>$config
 }
 
 function num_jobs_by_cpu
 {
 	if is_linux; then
 		typeset ncpu=$($NPROC --all)
 	else
 		typeset ncpu=$(psrinfo | $WC -l)
 	fi
 	typeset num_jobs=$ncpu
 
 	[[ $ncpu -gt 8 ]] && num_jobs=$(echo "$ncpu * 3 / 4" | bc)
 
 	echo $num_jobs
 }
 
 #
 # On illumos this looks like: ":sd3:sd4:sd1:sd2:"
 #
 function pool_to_lun_list
 {
 	typeset pool=$1
 	typeset ctd ctds devname lun
 	typeset lun_list=':'
 
 	if is_illumos; then
 		ctds=$(zpool list -v $pool |
 		    awk '/c[0-9]*t[0-9a-fA-F]*d[0-9]*/ {print $1}')
 
 		for ctd in $ctds; do
 		# Get the device name as it appears in /etc/path_to_inst
 		devname=$(readlink -f /dev/dsk/${ctd}s0 | sed -n \
 		    's/\/devices\([^:]*\):.*/\1/p')
 		# Add a string composed of the driver name and instance
 		# number to the list for comparison with dev_statname.
 		lun=$(sed 's/"//g' /etc/path_to_inst | grep \
 		    $devname | awk '{print $3$2}')
 		lun_list="$lun_list$lun:"
 		done
 	elif is_freebsd; then
 		lun_list+=$(zpool list -HLv $pool | \
 		    awk '/a?da[0-9]+|md[0-9]+|mfid[0-9]+|nda[0-9]+|nvd[0-9]+|vtbd[0-9]+/
 		         { printf "%s:", $1 }')
 	elif is_linux; then
 		ctds=$(zpool list -HLv $pool | \
 		    awk '/sd[a-z]*|loop[0-9]*|dm-[0-9]*/ {print $1}')
 
 		for ctd in $ctds; do
 			lun_list="$lun_list$ctd:"
 		done
 	fi
 	echo $lun_list
 }
 
 function print_perf_settings
 {
 	echo "PERF_NTHREADS: $PERF_NTHREADS"
 	echo "PERF_NTHREADS_PER_FS: $PERF_NTHREADS_PER_FS"
 	echo "PERF_SYNC_TYPES: $PERF_SYNC_TYPES"
 	echo "PERF_IOSIZES: $PERF_IOSIZES"
 }
 
 # Create a perf_data directory to hold performance statistics and
 # configuration information.
 export PERF_DATA_DIR=$(get_perf_output_dir)
 [[ -f $PERF_DATA_DIR/config.json ]] || get_system_config config.json
diff --git a/tests/zfs-tests/tests/perf/regression/random_reads.ksh b/tests/zfs-tests/tests/perf/regression/random_reads.ksh
index 5c8066d17549..70e273166161 100755
--- a/tests/zfs-tests/tests/perf/regression/random_reads.ksh
+++ b/tests/zfs-tests/tests/perf/regression/random_reads.ksh
@@ -1,96 +1,97 @@
 #!/bin/ksh
 
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2015, 2021 by Delphix. All rights reserved.
 #
 
 #
 # Description:
 # Trigger fio runs using the random_reads job file. The number of runs and
 # data collected is determined by the PERF_* variables. See do_fio_run for
 # details about these variables.
 #
 # The files to read from are created prior to the first fio run, and used
 # for all fio runs. The ARC is cleared with `zinject -a` prior to each run
 # so reads will go to disk.
 #
 # Thread/Concurrency settings:
 #    PERF_NTHREADS defines the number of files created in the test filesystem,
 #    as well as the number of threads that will simultaneously drive IO to
 #    those files.  The settings chosen are from measurements in the
 #    PerfAutoESX/ZFSPerfESX Environments, selected at concurrency levels that
 #    are at peak throughput but lowest latency.  Higher concurrency introduces
 #    queue time latency and would reduce the impact of code-induced performance
 #    regressions.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during random read load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 populate_perf_filesystems
 
 # Aim to fill the pool to 50% capacity while accounting for a 3x compressratio.
 export TOTAL_SIZE=$(($(get_prop avail $PERFPOOL) * 3 / 2))
 
 # Variables specific to this test for use by fio.
 export PERF_NTHREADS=${PERF_NTHREADS:-'16 32'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0'}
 export PERF_IOSIZES=${PERF_IOSIZES:-'8k'}
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'1'}
 
 # Layout the files to be used by the read tests. Create as many files as the
 # largest number of threads. An fio run with fewer threads will use a subset
 # of the available files.
 export NUMJOBS=$(get_max $PERF_NTHREADS)
 export FILE_SIZE=$((TOTAL_SIZE / NUMJOBS))
 export DIRECTORY=$(get_directory)
 log_must fio $FIO_SCRIPTS/mkfiles.fio
 
 # Set up the scripts and output files that will log performance data.
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
 	typeset perf_record_cmd="perf record -F 99 -a -g -q \
 	    -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
         export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "$PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "vmstat -T d 1" "vmstat"
 	    "mpstat -T d 1" "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	)
 fi
 
 log_note "Random reads with settings: $(print_perf_settings)"
 do_fio_run random_reads.fio false true
 log_pass "Measure IO stats during random read load"
diff --git a/tests/zfs-tests/tests/perf/regression/random_readwrite.ksh b/tests/zfs-tests/tests/perf/regression/random_readwrite.ksh
index 33d7d8c8d945..4dc1e3ddba9a 100755
--- a/tests/zfs-tests/tests/perf/regression/random_readwrite.ksh
+++ b/tests/zfs-tests/tests/perf/regression/random_readwrite.ksh
@@ -1,96 +1,97 @@
 #!/bin/ksh
 
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2015, 2021 by Delphix. All rights reserved.
 #
 
 #
 # Description:
 # Trigger fio runs using the random_readwrite job file. The number of runs and
 # data collected is determined by the PERF_* variables. See do_fio_run for
 # details about these variables.
 #
 # The files to read and write from are created prior to the first fio run,
 # and used for all fio runs. The ARC is cleared with `zinject -a` prior to
 # each run so reads will go to disk.
 #
 # Thread/Concurrency settings:
 #    PERF_NTHREADS defines the number of files created in the test filesystem,
 #    as well as the number of threads that will simultaneously drive IO to
 #    those files.  The settings chosen are from measurements in the
 #    PerfAutoESX/ZFSPerfESX Environments, selected at concurrency levels that
 #    are at peak throughput but lowest latency.  Higher concurrency introduces
 #    queue time latency and would reduce the impact of code-induced performance
 #    regressions.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during random read load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 populate_perf_filesystems
 
 # Aim to fill the pool to 50% capacity while accounting for a 3x compressratio.
 export TOTAL_SIZE=$(($(get_prop avail $PERFPOOL) * 3 / 2))
 
 # Variables specific to this test for use by fio.
 export PERF_NTHREADS=${PERF_NTHREADS:-'32 64'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0'}
 export PERF_IOSIZES=''		# bssplit used instead
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'1'}
 
 # Layout the files to be used by the readwrite tests. Create as many files
 # as the largest number of threads. An fio run with fewer threads will use
 # a subset of the available files.
 export NUMJOBS=$(get_max $PERF_NTHREADS)
 export FILE_SIZE=$((TOTAL_SIZE / NUMJOBS))
 export DIRECTORY=$(get_directory)
 log_must fio $FIO_SCRIPTS/mkfiles.fio
 
 # Set up the scripts and output files that will log performance data.
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
 	typeset perf_record_cmd="perf record -F 99 -a -g -q \
 	    -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
 	export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "$PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "vmstat -T d 1" "vmstat"
 	    "mpstat -T d 1" "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	)
 fi
 
 log_note "Random reads and writes with settings: $(print_perf_settings)"
 do_fio_run random_readwrite.fio false true
 log_pass "Measure IO stats during random read and write load"
diff --git a/tests/zfs-tests/tests/perf/regression/random_readwrite_fixed.ksh b/tests/zfs-tests/tests/perf/regression/random_readwrite_fixed.ksh
index bb4014563f1f..cdf15c701277 100755
--- a/tests/zfs-tests/tests/perf/regression/random_readwrite_fixed.ksh
+++ b/tests/zfs-tests/tests/perf/regression/random_readwrite_fixed.ksh
@@ -1,88 +1,89 @@
 #!/bin/ksh
 
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2017, 2021 by Delphix. All rights reserved.
 #
 
 #
 # Description:
 # Trigger fio runs using the random_readwrite_fixed job file. The number of runs and
 # data collected is determined by the PERF_* variables. See do_fio_run for
 # details about these variables.
 #
 # The files to read and write from are created prior to the first fio run,
 # and used for all fio runs. The ARC is cleared with `zinject -a` prior to
 # each run so reads will go to disk.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during random read write load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 populate_perf_filesystems
 
 # Aim to fill the pool to 50% capacity while accounting for a 3x compressratio.
 export TOTAL_SIZE=$(($(get_prop avail $PERFPOOL) * 3 / 2))
 
 # Variables specific to this test for use by fio.
 export PERF_NTHREADS=${PERF_NTHREADS:-'64 128'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0'}
 export PERF_IOSIZES=${PERF_IOSIZES:-'8k'}
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'0 1'}
 
 # Layout the files to be used by the readwrite tests. Create as many files
 # as the largest number of threads. An fio run with fewer threads will use
 # a subset of the available files.
 export NUMJOBS=$(get_max $PERF_NTHREADS)
 export FILE_SIZE=$((TOTAL_SIZE / NUMJOBS))
 export DIRECTORY=$(get_directory)
 log_must fio $FIO_SCRIPTS/mkfiles.fio
 
 # Set up the scripts and output files that will log performance data.
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
 	typeset perf_record_cmd="perf record -F 99 -a -g -q \
 	    -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
 	export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "kstat zfs:0 1"  "kstat"
 	    "vmstat -T d 1"       "vmstat"
 	    "mpstat -T d 1"       "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	    "dtrace -Cs $PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "dtrace  -s $PERF_SCRIPTS/profile.d"                  "profile"
 	)
 fi
 
 log_note "Random reads and writes with settings: $(print_perf_settings)"
 do_fio_run random_readwrite_fixed.fio false true
 log_pass "Measure IO stats during random read and write load"
diff --git a/tests/zfs-tests/tests/perf/regression/random_writes.ksh b/tests/zfs-tests/tests/perf/regression/random_writes.ksh
index 4b826835efbf..30db7564c2dc 100755
--- a/tests/zfs-tests/tests/perf/regression/random_writes.ksh
+++ b/tests/zfs-tests/tests/perf/regression/random_writes.ksh
@@ -1,87 +1,88 @@
 #!/bin/ksh
 
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2015, 2021 by Delphix. All rights reserved.
 #
 
 #
 # Description:
 # Trigger fio runs using the random_writes job file. The number of runs and
 # data collected is determined by the PERF_* variables. See do_fio_run for
 # details about these variables.
 #
 # Prior to each fio run the dataset is recreated, and fio writes new files
 # into an otherwise empty pool.
 #
 # Thread/Concurrency settings:
 #    PERF_NTHREADS defines the number of files created in the test filesystem,
 #    as well as the number of threads that will simultaneously drive IO to
 #    those files.  The settings chosen are from measurements in the
 #    PerfAutoESX/ZFSPerfESX Environments, selected at concurrency levels that
 #    are at peak throughput but lowest latency.  Higher concurrency introduces
 #    queue time latency and would reduce the impact of code-induced performance
 #    regressions.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during random read load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 populate_perf_filesystems
 
 # Aim to fill the pool to 50% capacity while accounting for a 3x compressratio.
 export TOTAL_SIZE=$(($(get_prop avail $PERFPOOL) * 3 / 2))
 
 # Variables specific to this test for use by fio.
 export PERF_NTHREADS=${PERF_NTHREADS:-'32 128'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0'}
 export PERF_IOSIZES=${PERF_IOSIZES:-'8k'}
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'0 1'}
 
 # Set up the scripts and output files that will log performance data.
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
 	typeset perf_record_cmd="perf record -F 99 -a -g -q \
 	    -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
 	export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "$PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "vmstat -T d 1" "vmstat"
 	    "mpstat -T d 1" "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	)
 fi
 
 log_note "Random writes with settings: $(print_perf_settings)"
 do_fio_run random_writes.fio true false
 log_pass "Measure IO stats during random write load"
diff --git a/tests/zfs-tests/tests/perf/regression/random_writes_zil.ksh b/tests/zfs-tests/tests/perf/regression/random_writes_zil.ksh
index 522ee4526828..ff6d465bb722 100755
--- a/tests/zfs-tests/tests/perf/regression/random_writes_zil.ksh
+++ b/tests/zfs-tests/tests/perf/regression/random_writes_zil.ksh
@@ -1,83 +1,84 @@
 #!/bin/ksh
 
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2015, 2021 by Delphix. All rights reserved.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 
 	#
 	# We're using many filesystems depending on the number of
 	# threads for each test, and there's no good way to get a list
 	# of all the filesystems that should be destroyed on cleanup
 	# (i.e. the list of filesystems used for the last test ran).
 	# Thus, we simply recreate the pool as a way to destroy all
 	# filesystems and leave a fresh pool behind.
 	#
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during random write load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 
 # Aim to fill the pool to 50% capacity while accounting for a 3x compressratio.
 export TOTAL_SIZE=$(($(get_prop avail $PERFPOOL) * 3 / 2))
 
 # Variables specific to this test for use by fio.
-export PERF_NTHREADS=${PERF_NTHREADS:-'1 4 16 64'}
+export PERF_NTHREADS=${PERF_NTHREADS:-'1 16 64'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0 1'}
 export PERF_IOSIZES=${PERF_IOSIZES:-'8k'}
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'1'}
 
 # Until the performance tests over NFS can deal with multiple file systems,
 # force the use of only one file system when testing over NFS.
 [[ $NFS -eq 1 ]] && PERF_NTHREADS_PER_FS='0'
 
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
 	typeset perf_record_cmd="perf record -F 99 -a -g -q \
 	    -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
 	export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "kstat zfs:0 1" "kstat"
 	    "vmstat -T d 1" "vmstat"
 	    "mpstat -T d 1" "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	    "dtrace -Cs $PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "dtrace  -s $PERF_SCRIPTS/zil.d $PERFPOOL 1" "zil"
 	    "dtrace  -s $PERF_SCRIPTS/profile.d" "profile"
 	    "dtrace  -s $PERF_SCRIPTS/offcpu-profile.d" "offcpu-profile"
 	)
 fi
 log_note \
     "ZIL specific random write workload with settings: $(print_perf_settings)"
 do_fio_run random_writes.fio true false
 log_pass "Measure IO stats during ZIL specific random write workload"
diff --git a/tests/zfs-tests/tests/perf/regression/sequential_reads.ksh b/tests/zfs-tests/tests/perf/regression/sequential_reads.ksh
index 2bdfff736f4e..cc6d17245239 100755
--- a/tests/zfs-tests/tests/perf/regression/sequential_reads.ksh
+++ b/tests/zfs-tests/tests/perf/regression/sequential_reads.ksh
@@ -1,98 +1,99 @@
 #!/bin/ksh
 
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2015, 2021 by Delphix. All rights reserved.
 #
 
 #
 # Description:
 # Trigger fio runs using the sequential_reads job file. The number of runs and
 # data collected is determined by the PERF_* variables. See do_fio_run for
 # details about these variables.
 #
 # The files to read from are created prior to the first fio run, and used
 # for all fio runs. The ARC is cleared with `zinject -a` prior to each run
 # so reads will go to disk.
 #
 # Thread/Concurrency settings:
 #    PERF_NTHREADS defines the number of files created in the test filesystem,
 #    as well as the number of threads that will simultaneously drive IO to
 #    those files.  The settings chosen are from measurements in the
 #    PerfAutoESX/ZFSPerfESX Environments, selected at concurrency levels that
 #    are at peak throughput but lowest latency.  Higher concurrency introduces
 #    queue time latency and would reduce the impact of code-induced performance
 #    regressions.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during random read load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 populate_perf_filesystems
 
 # Aim to fill the pool to 50% capacity while accounting for a 3x compressratio.
 export TOTAL_SIZE=$(($(get_prop avail $PERFPOOL) * 3 / 2))
 
 # Variables specific to this test for use by fio.
 export PERF_NTHREADS=${PERF_NTHREADS:-'8 16'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0'}
 export PERF_IOSIZES=${PERF_IOSIZES:-'128k 1m'}
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'1'}
 
 # Layout the files to be used by the read tests. Create as many files as the
 # largest number of threads. An fio run with fewer threads will use a subset
 # of the available files.
 export NUMJOBS=$(get_max $PERF_NTHREADS)
 export FILE_SIZE=$((TOTAL_SIZE / NUMJOBS))
 export DIRECTORY=$(get_directory)
 log_must fio $FIO_SCRIPTS/mkfiles.fio
 
 # Set up the scripts and output files that will log performance data.
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
     typeset perf_record_cmd="perf record -F 99 -a -g -q \
         -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
 	export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "$PERF_SCRIPTS/prefetch_io.sh $PERFPOOL 1" "prefetch"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "$PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "$PERF_SCRIPTS/prefetch_io.d $PERFPOOL 1" "prefetch"
 	    "vmstat -T d 1" "vmstat"
 	    "mpstat -T d 1" "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	)
 fi
 
 log_note "Sequential reads with settings: $(print_perf_settings)"
 do_fio_run sequential_reads.fio false true
 log_pass "Measure IO stats during sequential read load"
diff --git a/tests/zfs-tests/tests/perf/regression/sequential_reads_arc_cached.ksh b/tests/zfs-tests/tests/perf/regression/sequential_reads_arc_cached.ksh
index 8127786361ba..d885d0b7f992 100755
--- a/tests/zfs-tests/tests/perf/regression/sequential_reads_arc_cached.ksh
+++ b/tests/zfs-tests/tests/perf/regression/sequential_reads_arc_cached.ksh
@@ -1,88 +1,89 @@
 #!/bin/ksh
 
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2015, 2021 by Delphix. All rights reserved.
 #
 
 #
 # Description:
 # Trigger fio runs using the sequential_reads job file. The number of runs and
 # data collected is determined by the PERF_* variables. See do_fio_run for
 # details about these variables.
 #
 # The files to read from are created prior to the first fio run, and used
 # for all fio runs. The ARC is not cleared to ensure that all data is cached.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during random read load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 populate_perf_filesystems
 
 # Make sure the working set can be cached in the arc. Aim for 1/2 of arc.
 export TOTAL_SIZE=$(($(get_max_arc_size) / 2))
 
 # Variables specific to this test for use by fio.
 export PERF_NTHREADS=${PERF_NTHREADS:-'64 128'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0'}
-export PERF_IOSIZES=${PERF_IOSIZES:-'128k 1m'}
+export PERF_IOSIZES=${PERF_IOSIZES:-'128k'}
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'1'}
 
 # Layout the files to be used by the read tests. Create as many files as the
 # largest number of threads. An fio run with fewer threads will use a subset
 # of the available files.
 export NUMJOBS=$(get_max $PERF_NTHREADS)
 export FILE_SIZE=$((TOTAL_SIZE / NUMJOBS))
 export DIRECTORY=$(get_directory)
 log_must fio $FIO_SCRIPTS/mkfiles.fio
 
 # Set up the scripts and output files that will log performance data.
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
 	typeset perf_record_cmd="perf record -F 99 -a -g -q \
 	    -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
 	export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "$PERF_SCRIPTS/prefetch_io.sh $PERFPOOL 1" "prefetch"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "$PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "$PERF_SCRIPTS/prefetch_io.d $PERFPOOL 1" "prefetch"
 	    "vmstat -T d 1" "vmstat"
 	    "mpstat -T d 1" "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	)
 fi
 
 log_note "Sequential cached reads with settings: $(print_perf_settings)"
 do_fio_run sequential_reads.fio false false
 log_pass "Measure IO stats during sequential cached read load"
diff --git a/tests/zfs-tests/tests/perf/regression/sequential_reads_arc_cached_clone.ksh b/tests/zfs-tests/tests/perf/regression/sequential_reads_arc_cached_clone.ksh
index 8ce1273c2869..80081a098e8f 100755
--- a/tests/zfs-tests/tests/perf/regression/sequential_reads_arc_cached_clone.ksh
+++ b/tests/zfs-tests/tests/perf/regression/sequential_reads_arc_cached_clone.ksh
@@ -1,115 +1,116 @@
 #!/bin/ksh
 
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2015, 2021 by Delphix. All rights reserved.
 #
 
 #
 # Description:
 # Trigger fio runs using the sequential_reads job file. The number of runs and
 # data collected is determined by the PERF_* variables. See do_fio_run for
 # details about these variables.
 #
 # The files to read from are created prior to the first fio run, and used
 # for all fio runs. This test will exercise cached read performance from
 # a clone filesystem. The data is initially cached in the ARC and then
 # a snapshot and clone are created. All the performance runs are then
 # initiated against the clone filesystem to exercise the performance of
 # reads when the ARC has to create another buffer from a different dataset.
 # It will also exercise the need to evict the duplicate buffer once the last
 # reference on that buffer is released.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during random read load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 populate_perf_filesystems
 
 # Make sure the working set can be cached in the arc. Aim for 1/2 of arc.
 export TOTAL_SIZE=$(($(get_max_arc_size) / 2))
 
 # Variables specific to this test for use by fio.
 export PERF_NTHREADS=${PERF_NTHREADS:-'64 128'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0'}
-export PERF_IOSIZES=${PERF_IOSIZES:-'128k 1m'}
+export PERF_IOSIZES=${PERF_IOSIZES:-'128k'}
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'1'}
 
 # Layout the files to be used by the read tests. Create as many files as the
 # largest number of threads. An fio run with fewer threads will use a subset
 # of the available files.
 export NUMJOBS=$(get_max $PERF_NTHREADS)
 export FILE_SIZE=$((TOTAL_SIZE / NUMJOBS))
 export DIRECTORY=$(get_directory)
 log_must fio $FIO_SCRIPTS/mkfiles.fio
 
 #
 # Only a single filesystem is used by this test. To be defensive, we
 # double check that TESTFS only contains a single filesystem. We
 # wouldn't want to assume this was the case, and have it actually
 # contain multiple filesystem (causing cascading failures later).
 #
 log_must test $(get_nfilesystems) -eq 1
 
 log_note "Creating snapshot, $TESTSNAP, of $TESTFS"
 create_snapshot $TESTFS $TESTSNAP
 log_note "Creating clone, $PERFPOOL/$TESTCLONE, from $TESTFS@$TESTSNAP"
 create_clone $TESTFS@$TESTSNAP $PERFPOOL/$TESTCLONE
 
 #
 # We want to run FIO against the clone we created above, and not the
 # clone's originating filesystem. Thus, we override the default behavior
 # and explicitly set TESTFS to the clone.
 #
 export TESTFS=$PERFPOOL/$TESTCLONE
 
 # Set up the scripts and output files that will log performance data.
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
 	typeset perf_record_cmd="perf record -F 99 -a -g -q \
 	    -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
 	export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "$PERF_SCRIPTS/prefetch_io.sh $PERFPOOL 1" "prefetch"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "$PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "$PERF_SCRIPTS/prefetch_io.d $PERFPOOL 1" "prefetch"
 	    "vmstat -T d 1" "vmstat"
 	    "mpstat -T d 1" "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	)
 fi
 
 log_note "Sequential cached reads from $DIRECTORY with " \
     "ettings: $(print_perf_settings)"
 do_fio_run sequential_reads.fio false false
 log_pass "Measure IO stats during sequential cached read load"
diff --git a/tests/zfs-tests/tests/perf/regression/sequential_reads_dbuf_cached.ksh b/tests/zfs-tests/tests/perf/regression/sequential_reads_dbuf_cached.ksh
index adacdc29799c..0402b48a3e9c 100755
--- a/tests/zfs-tests/tests/perf/regression/sequential_reads_dbuf_cached.ksh
+++ b/tests/zfs-tests/tests/perf/regression/sequential_reads_dbuf_cached.ksh
@@ -1,94 +1,95 @@
 #!/bin/ksh
 
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2016, 2021 by Delphix. All rights reserved.
 #
 
 #
 # Description:
 # Trigger fio runs using the sequential_reads job file. The number of runs and
 # data collected is determined by the PERF_* variables. See do_fio_run for
 # details about these variables.
 #
 # The files to read from are created prior to the first fio run, and used
 # for all fio runs. The ARC is not cleared to ensure that all data is cached.
 #
 # This is basically a copy of the sequential_reads_cached test case, but with
 # a smaller dataset so that we can fit everything into the decompressed, linear
 # space in the dbuf cache.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during sequential read load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 populate_perf_filesystems
 
 # Ensure the working set can be cached in the dbuf cache.
 export TOTAL_SIZE=$(($(get_dbuf_cache_size) * 3 / 4))
 
 # Variables specific to this test for use by fio.
 export PERF_NTHREADS=${PERF_NTHREADS:-'64'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0'}
 export PERF_IOSIZES=${PERF_IOSIZES:-'64k'}
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'1'}
 
 # Layout the files to be used by the read tests. Create as many files as the
 # largest number of threads. An fio run with fewer threads will use a subset
 # of the available files.
 export NUMJOBS=$(get_max $PERF_NTHREADS)
 export FILE_SIZE=$((TOTAL_SIZE / NUMJOBS))
 export DIRECTORY=$(get_directory)
 log_must fio $FIO_SCRIPTS/mkfiles.fio
 
 # Set up the scripts and output files that will log performance data.
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
 	typeset perf_record_cmd="perf record -F 99 -a -g -q \
 	    -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
 	export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "$PERF_SCRIPTS/prefetch_io.sh $PERFPOOL 1" "prefetch"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "kstat zfs:0 1" "kstat"
 	    "vmstat -T d 1" "vmstat"
 	    "mpstat -T d 1" "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	    "dtrace -Cs $PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "dtrace -Cs $PERF_SCRIPTS/prefetch_io.d $PERFPOOL 1" "prefetch"
 	    "dtrace -s $PERF_SCRIPTS/profile.d" "profile"
 	)
 fi
 
 log_note "Sequential cached reads with settings: $(print_perf_settings)"
 do_fio_run sequential_reads.fio false false
 log_pass "Measure IO stats during sequential cached read load"
diff --git a/tests/zfs-tests/tests/perf/regression/sequential_writes.ksh b/tests/zfs-tests/tests/perf/regression/sequential_writes.ksh
index d32690a0542e..7850bc0375df 100755
--- a/tests/zfs-tests/tests/perf/regression/sequential_writes.ksh
+++ b/tests/zfs-tests/tests/perf/regression/sequential_writes.ksh
@@ -1,87 +1,88 @@
 #!/bin/ksh
 
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 
 #
 # Copyright (c) 2015, 2021 by Delphix. All rights reserved.
 #
 
 #
 # Description:
 # Trigger fio runs using the sequential_writes job file. The number of runs and
 # data collected is determined by the PERF_* variables. See do_fio_run for
 # details about these variables.
 #
 # Prior to each fio run the dataset is recreated, and fio writes new files
 # into an otherwise empty pool.
 #
 # Thread/Concurrency settings:
 #    PERF_NTHREADS defines the number of files created in the test filesystem,
 #    as well as the number of threads that will simultaneously drive IO to
 #    those files.  The settings chosen are from measurements in the
 #    PerfAutoESX/ZFSPerfESX Environments, selected at concurrency levels that
 #    are at peak throughput but lowest latency.  Higher concurrency introduces
 #    queue time latency and would reduce the impact of code-induced performance
 #    regressions.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/perf/perf.shlib
 
 function cleanup
 {
 	# kill fio and iostat
 	pkill fio
 	pkill iostat
 	recreate_perf_pool
 }
 
 trap "log_fail \"Measure IO stats during random read load\"" SIGTERM
 log_onexit cleanup
 
 recreate_perf_pool
 populate_perf_filesystems
 
 # Aim to fill the pool to 50% capacity while accounting for a 3x compressratio.
 export TOTAL_SIZE=$(($(get_prop avail $PERFPOOL) * 3 / 2))
 
 # Variables specific to this test for use by fio.
 export PERF_NTHREADS=${PERF_NTHREADS:-'16 32'}
 export PERF_NTHREADS_PER_FS=${PERF_NTHREADS_PER_FS:-'0'}
-export PERF_IOSIZES=${PERF_IOSIZES:-'8k 128k 1m'}
+export PERF_IOSIZES=${PERF_IOSIZES:-'8k 1m'}
+export PERF_SYNC_TYPES=${PERF_SYNC_TYPES:-'0 1'}
 
 # Set up the scripts and output files that will log performance data.
 lun_list=$(pool_to_lun_list $PERFPOOL)
 log_note "Collecting backend IO stats with lun list $lun_list"
 if is_linux; then
 	typeset perf_record_cmd="perf record -F 99 -a -g -q \
 	    -o /dev/stdout -- sleep ${PERF_RUNTIME}"
 
 	export collect_scripts=(
 	    "zpool iostat -lpvyL $PERFPOOL 1" "zpool.iostat"
 	    "vmstat -t 1" "vmstat"
 	    "mpstat -P ALL 1" "mpstat"
 	    "iostat -tdxyz 1" "iostat"
 	    "$perf_record_cmd" "perf"
 	)
 else
 	export collect_scripts=(
 	    "$PERF_SCRIPTS/io.d $PERFPOOL $lun_list 1" "io"
 	    "vmstat -T d 1" "vmstat"
 	    "mpstat -T d 1" "mpstat"
 	    "iostat -T d -xcnz 1" "iostat"
 	)
 fi
 
 log_note "Sequential writes with settings: $(print_perf_settings)"
 do_fio_run sequential_writes.fio true false
 log_pass "Measure IO stats during sequential write load"