shift 2
r=$(((RANDOM << 16) | RANDOM))
write_opts=(--name="write_job" --rw=write "$(ioengine "psync")" \
- --bs="${logical_block_size}" --zonemode=zbd \
+ --bs="${min_seq_write_size}" --zonemode=zbd \
--zonesize="${zone_size}" --thread=1 --direct=1 \
--offset="${write_offset}" --size="${write_size}")
write_opts+=("${job_var_opts[@]}")
return 0
}
+require_max_active_zones() {
+ local min=${1}
+
+ if ((max_active_zones == 0)); then
+ SKIP_REASON="$dev does not have max_active_zones limit"
+ return 1
+ fi
+ if ((max_active_zones < min)); then
+ SKIP_REASON="max_active_zones of $dev is smaller than $min"
+ return 1
+ fi
+ return 0
+}
+
# Check whether buffered writes are refused for block devices.
test1() {
require_block_dev || return $SKIP_TESTCASE
size=$((zone_size))
[ -n "$is_zbd" ] && reset_zone "$dev" $((off / 512))
opts+=("--name=$dev" "--filename=$dev" "--offset=$off")
- opts+=(--bs="$(min $((logical_block_size * 256)) $size)")
+ opts+=(--bs="$(min $((min_seq_write_size * 256)) $size)")
opts+=("--size=$size" "--thread=1" "--read_beyond_wp=1")
opts+=("$(ioengine "psync")" "--rw=read" "--direct=1" "--disable_lat=1")
opts+=("--zonemode=zbd" "--zonesize=${zone_size}")
off=$((first_sequential_zone_sector * 512))
capacity=$(total_zone_capacity 4 $off $dev)
size=$((4 * zone_size))
- bs=$(min "$(max $((zone_size / 64)) "$logical_block_size")" "$zone_cap_bs")
+ bs=$(min "$(max $((zone_size / 64)) "$min_seq_write_size")" "$zone_cap_bs")
run_fio_on_seq "$(ioengine "psync")" --iodepth=1 --rw=write \
--bs="$bs" --do_verify=1 --verify=md5 \
>>"${logfile}.${test_number}" 2>&1 || return $?
off=$((first_sequential_zone_sector * 512))
capacity=$(total_zone_capacity 4 $off $dev)
size=$((4 * zone_size))
- bs=$(min "$(max $((zone_size / 64)) "$logical_block_size")" "$zone_cap_bs")
+ bs=$(min "$(max $((zone_size / 64)) "$min_seq_write_size")" "$zone_cap_bs")
write_and_run_one_fio_job \
$((first_sequential_zone_sector * 512)) "${size}" \
--offset="${off}" \
test12() {
local size off capacity
- prep_write
+ [ -n "$is_zbd" ] && reset_zone "$dev" -1
+
size=$((8 * zone_size))
off=$((first_sequential_zone_sector * 512))
capacity=$(total_zone_capacity 8 $off $dev)
require_max_open_zones 4 || return $SKIP_TESTCASE
- prep_write
+ [ -n "$is_zbd" ] && reset_zone "$dev" -1
+
size=$((8 * zone_size))
off=$((first_sequential_zone_sector * 512))
capacity=$(total_zone_capacity 8 $off $dev)
require_seq_zones 80 || return $SKIP_TESTCASE
off=$((first_sequential_zone_sector * 512 + 64 * zone_size))
size=$((16*zone_size))
- prep_write
+
+ [ -n "$is_zbd" ] && reset_zone "$dev" -1
+
opts=("--debug=zbd")
for ((i=0;i<jobs;i++)); do
opts+=("--name=job$i" "--filename=$dev" "--offset=$off" "--bs=16K")
prep_write
off=$((first_sequential_zone_sector * 512))
run_one_fio_job "$(ioengine "libaio")" --iodepth=8 --rw=randrw \
- --bs="$(max $((zone_size / 128)) "$logical_block_size")"\
+ --bs="$(max $((zone_size / 128)) "$min_seq_write_size")"\
--zonemode=zbd --zonesize="${zone_size}" --offset=$off\
--loops=2 --time_based --runtime=30s --norandommap=1\
>>"${logfile}.${test_number}" 2>&1
require_zbd || return $SKIP_TESTCASE
- prep_write
+ [ -n "$is_zbd" ] && reset_zone "$dev" -1
+
off=$((first_sequential_zone_sector * 512))
size=$((disk_size - off))
opts+=("--name=$dev" "--filename=$dev" "--offset=$off" "--size=$size")
check_written $((io_size / bs * bs)) || return $?
}
-# Write to sequential zones with a block size that is not a divisor of the
-# zone size and with data verification enabled.
+# Test repeated async write job with verify using two unaligned block sizes.
test34() {
- local size
+ local bs off zone_capacity
+ local -a block_sizes
- prep_write
- size=$((2 * zone_size))
- run_fio_on_seq "$(ioengine "psync")" --iodepth=1 --rw=write --size=$size \
- --do_verify=1 --verify=md5 --bs=$((3 * zone_size / 4)) \
- >> "${logfile}.${test_number}" 2>&1 && return 1
- grep -q 'not a divisor of' "${logfile}.${test_number}"
+ require_zbd || return $SKIP_TESTCASE
+ prep_write
+
+ off=$((first_sequential_zone_sector * 512))
+ zone_capacity=$(total_zone_capacity 1 $off $dev)
+ block_sizes=($((4096 * 7)) $(($(min ${zone_capacity} 4194304) - 4096)))
+
+ for bs in ${block_sizes[@]}; do
+ run_fio --name=job --filename="${dev}" --rw=randwrite \
+ --bs="${bs}" --offset="${off}" \
+ --size=$((4 * zone_size)) --iodepth=256 \
+ "$(ioengine "libaio")" --time_based=1 --runtime=15s \
+ --zonemode=zbd --direct=1 --zonesize="${zone_size}" \
+ --verify=crc32c --do_verify=1 ${job_var_opts[@]} \
+ >> "${logfile}.${test_number}" 2>&1 || return $?
+ done
}
# Test 1/4 for the I/O boundary rounding code: $size < $zone_size.
local bs off size
prep_write
- size=$((logical_block_size))
- off=$((disk_size - logical_block_size))
- bs=$((logical_block_size))
+ size=$((min_seq_write_size))
+ off=$((disk_size - min_seq_write_size))
+ bs=$((min_seq_write_size))
run_one_fio_job --offset=$off --size=$size "$(ioengine "psync")" \
--iodepth=1 --rw=write --do_verify=1 --verify=md5 \
--bs=$bs --zonemode=zbd --zonesize="${zone_size}" \
exit 1
fi
off=${result[0]}
- bs=$((logical_block_size))
+ bs=$((min_seq_write_size))
run_one_fio_job --rw=read "$(ioengine "psync")" --offset=$off --bs=$bs \
--size=$bs "$@" 2>&1 |
tee -a "${logfile}.${test_number}"
test39() {
require_zbd || return $SKIP_TESTCASE
read_one_block --zonemode=none >/dev/null || return $?
- check_read $((logical_block_size)) || return $?
+ check_read $((min_seq_write_size)) || return $?
}
# Check whether fio accepts --zonemode=strided for zoned block devices.
test40() {
local bs
- bs=$((logical_block_size))
+ bs=$((min_seq_write_size))
require_zbd || return $SKIP_TESTCASE
read_one_block --zonemode=strided |
grep -q 'fio: --zonesize must be specified when using --zonemode=strided' ||
require_zbd || return $SKIP_TESTCASE
prep_write
- bs=$((logical_block_size))
+ bs=$((min_seq_write_size))
run_one_fio_job "$(ioengine "psync")" --iodepth=1 --rw=randwrite --bs=$bs\
--offset=$((first_sequential_zone_sector * 512)) \
--size="$zone_size" --do_verify=1 --verify=md5 2>&1 |
local bs
prep_write
- bs=$((logical_block_size))
+ bs=$((min_seq_write_size))
run_fio_on_seq "$(ioengine "psync")" --rw=write --bs=$bs --zoneskip=1 \
>> "${logfile}.${test_number}" 2>&1 && return 1
grep -q 'zoneskip 1 is not a multiple of the device zone size' "${logfile}.${test_number}"
off=$((first_sequential_zone_sector * 512 + 64 * zone_size))
size=$((16*zone_size))
- prep_write
+
+ [ -n "$is_zbd" ] && reset_zone "$dev" -1
+
opts=("--aux-path=/tmp" "--allow_file_create=0" "--significant_figures=10")
opts+=("--debug=zbd")
opts+=("$(ioengine "libaio")" "--rw=randwrite" "--direct=1")
require_conv_zones 8 || return $SKIP_TESTCASE
require_seq_zones 8 || return $SKIP_TESTCASE
- prep_write
+ reset_zone "$dev" -1
off=$((first_sequential_zone_sector * 512 - 8 * zone_size))
opts+=("--size=$((16 * zone_size))" "$(ioengine "libaio")")
run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
}
-# Verify that zone_reset_threshold only takes logical blocks from seq
-# zones into account, and logical blocks of conv zones are not counted.
+# Verify that zone_reset_threshold only accounts written bytes in seq
+# zones, and written data bytes of conv zones are not counted.
test52() {
local off io_size
--rw=randrw:2 --rwmixwrite=25 --bsrange=4k-${zone_size} \
--zonemode=zbd --zonesize=${zone_size} \
--verify=crc32c --do_verify=1 --verify_backlog=2 \
- --experimental_verify=1 \
--alloc-size=65536 --random_generator=tausworthe64 \
${job_var_opts[@]} --debug=zbd \
>> "${logfile}.${test_number}" 2>&1 || return $?
# test 'z' suffix parsing only
test55() {
local bs
- bs=$((logical_block_size))
+ bs=$((min_seq_write_size))
require_zbd || return $SKIP_TESTCASE
# offset=1z + offset_increment=10z + size=2z
# test 'z' suffix parsing only
test56() {
local bs
- bs=$((logical_block_size))
+ bs=$((min_seq_write_size))
require_regular_block_dev || return $SKIP_TESTCASE
require_seq_zones 10 || return $SKIP_TESTCASE
require_seq_zones 128 || return $SKIP_TESTCASE
size=$((zone_size * 128))
- bs="$(max $((zone_size / 128)) "$logical_block_size")"
+ bs="$(max $((zone_size / 128)) "$min_seq_write_size")"
prep_write
off=$((first_sequential_zone_sector * 512))
run_fio --zonemode=zbd --direct=1 --zonesize="${zone_size}" --thread=1 \
>>"${logfile}.${test_number}" 2>&1
}
+# Test zone_reset_threshold with verify.
+test59() {
+ local off bs loops=2 size=$((zone_size)) w
+ local -a workloads=(write randwrite rw randrw)
+
+ prep_write
+ off=$((first_sequential_zone_sector * 512))
+
+ bs=$(min $((256*1024)) "$zone_size")
+ for w in "${workloads[@]}"; do
+ run_fio_on_seq "$(ioengine "psync")" --rw=${w} --bs="$bs" \
+ --size=$size --loops=$loops --do_verify=1 \
+ --verify=md5 --zone_reset_frequency=.9 \
+ --zone_reset_threshold=.1 \
+ >> "${logfile}.${test_number}" 2>&1 || return $?
+ done
+}
+
+# Test fio errors out experimental_verify option with zonemode=zbd.
+test60() {
+ run_fio_on_seq "$(ioengine "psync")" --rw=write --size=$zone_size \
+ --do_verify=1 --verify=md5 --experimental_verify=1 \
+ >> "${logfile}.${test_number}" 2>&1 && return 1
+ grep -q 'not support experimental verify' "${logfile}.${test_number}"
+}
+
+# Test fio errors out zone_reset_threshold option for multiple jobs with
+# different write ranges.
+test61() {
+ run_fio_on_seq "$(ioengine "psync")" --rw=write --size="$zone_size" \
+ --numjobs=2 --offset_increment="$zone_size" \
+ --zone_reset_threshold=0.1 --zone_reset_frequency=1 \
+ --exitall_on_error=1 \
+ >> "${logfile}.${test_number}" 2>&1 && return 1
+ grep -q 'different write ranges' "${logfile}.${test_number}"
+}
+
+# Test zone_reset_threshold option works for multiple jobs with same write
+# range.
+test62() {
+ local bs loops=2 size=$((zone_size))
+
+ [ -n "$is_zbd" ] && reset_zone "$dev" -1
+
+ # Two jobs write to single zone twice. Reset zone happens at next write
+ # after half of the zone gets filled. So 2 * 2 * 2 - 1 = 7 times zone
+ # resets are expected.
+ bs=$(min $((256*1024)) $((zone_size / 4)))
+ run_fio_on_seq "$(ioengine "psync")" --rw=write --bs="$bs" \
+ --size=$size --loops=$loops --numjobs=2 \
+ --zone_reset_frequency=1 --zone_reset_threshold=.5 \
+ --group_reporting=1 \
+ >> "${logfile}.${test_number}" 2>&1 || return $?
+ check_written $((size * loops * 2)) || return $?
+ check_reset_count -eq 7 || return $?
+}
+
+# Test zone_reset_threshold option works for a read job and a write job with
+# different IO range.
+test63() {
+ local bs loops=2 size=$((zone_size)) off1 off2
+
+ [ -n "$is_zbd" ] && reset_zone "$dev" -1
+
+ off1=$((first_sequential_zone_sector * 512))
+ off2=$((off1 + zone_size))
+ bs=$(min $((256*1024)) $((zone_size / 4)))
+
+ # One job writes to single zone twice. Reset zone happens at next write
+ # after half of the zone gets filled. So 2 * 2 - 1 = 3 times zone resets
+ # are expected.
+ run_fio "$(ioengine "psync")" --bs="$bs" --size=$size --loops=$loops \
+ --filename="$dev" --group_reporting=1 \
+ --zonemode=zbd --zonesize="$zone_size" --direct=1 \
+ --zone_reset_frequency=1 --zone_reset_threshold=.5 \
+ --name=r --rw=read --offset=$off1 "${job_var_opts[@]}" \
+ --name=w --rw=write --offset=$off2 "${job_var_opts[@]}" \
+ >> "${logfile}.${test_number}" 2>&1 || return $?
+ check_written $((size * loops)) || return $?
+ check_reset_count -eq 3 || return $?
+}
+
+# Test write zone accounting handles almost full zones correctly. Prepare an
+# almost full, but not full zone. Write to the zone with verify using larger
+# block size. Then confirm fio does not report write zone accounting failure.
+test64() {
+ local bs cap
+
+ [ -n "$is_zbd" ] && reset_zone "$dev" -1
+
+ bs=$((zone_size / 8))
+ cap=$(total_zone_capacity 1 $((first_sequential_zone_sector*512)) $dev)
+ run_fio_on_seq "$(ioengine "psync")" --rw=write --bs="$bs" \
+ --size=$((zone_size)) \
+ --io_size=$((cap - bs)) \
+ >> "${logfile}.${test_number}" 2>&1 || return $?
+
+ bs=$((zone_size / 2))
+ run_fio_on_seq "$(ioengine "psync")" --rw=write --bs="$bs" \
+ --size=$((zone_size)) --do_verify=1 --verify=md5 \
+ >> "${logfile}.${test_number}" 2>&1 || return $?
+}
+
+# Test open zone accounting handles trim workload correctly. Prepare open zones
+# as many as max_open_zones=4. Trim one of the 4 zones. Then write to another
+# zone and check the write amount is expected size.
+test65() {
+ local off capacity
+
+ [ -n "$is_zbd" ] && reset_zone "$dev" -1
+
+ off=$((first_sequential_zone_sector * 512))
+ capacity=$(total_zone_capacity 1 $off "$dev")
+ run_fio --zonemode=zbd --direct=1 --zonesize="$zone_size" --thread=1 \
+ --filename="$dev" --group_reporting=1 --max_open_zones=4 \
+ "$(ioengine "psync")" \
+ --name="prep_open_zones" --rw=randwrite --offset="$off" \
+ --size="$((zone_size * 4))" --bs=4096 --io_size="$zone_size" \
+ --name=trimjob --wait_for="prep_open_zones" --rw=trim \
+ --bs="$zone_size" --offset="$off" --size="$zone_size" \
+ --name=write --wait_for="trimjob" --rw=write --bs=4096 \
+ --offset="$((off + zone_size * 4))" --size="$zone_size" \
+ >> "${logfile}.${test_number}" 2>&1
+
+ check_written $((zone_size + capacity))
+}
+
+# Test closed zones are handled as open zones. This test case requires zoned
+# block devices which has same max_open_zones and max_active_zones.
+test66() {
+ local i off
+
+ require_zbd || return $SKIP_TESTCASE
+ require_max_active_zones 2 || return $SKIP_TESTCASE
+ require_max_open_zones "${max_active_zones}" || return $SKIP_TESTCASE
+ require_seq_zones $((max_active_zones * 16)) || return $SKIP_TESTCASE
+
+ reset_zone "$dev" -1
+
+ # Prepare max_active_zones in closed condition.
+ off=$((first_sequential_zone_sector * 512))
+ run_fio --name=w --filename="$dev" --zonemod=zbd --direct=1 \
+ --offset=$((off)) --zonesize="${zone_size}" --rw=randwrite \
+ --bs=4096 --size="$((zone_size * max_active_zones))" \
+ --io_size="${zone_size}" "$(ioengine "psync")" \
+ >> "${logfile}.${test_number}" 2>&1 || return $?
+ for ((i = 0; i < max_active_zones; i++)); do
+ close_zone "$dev" $((off / 512)) || return $?
+ off=$((off + zone_size))
+ done
+
+ # Run random write to the closed zones and empty zones. This confirms
+ # that fio handles closed zones as write target open zones. Otherwise,
+ # fio writes to the empty zones and hit the max_active_zones limit.
+ off=$((first_sequential_zone_sector * 512))
+ run_one_fio_job --zonemod=zbd --direct=1 \
+ "$(ioengine "psync")" --rw=randwrite --bs=4096 \
+ --max_open_zones="$max_active_zones" --offset=$((off)) \
+ --size=$((max_active_zones * 16 * zone_size)) \
+ --io_size=$((zone_size)) --zonesize="${zone_size}" \
+ --time_based --runtime=5s \
+ >> "${logfile}.${test_number}" 2>&1
+}
+
+# Test max_active_zones limit failure is reported with good error message.
+test67() {
+ local i off
+
+ require_zbd || return $SKIP_TESTCASE
+ require_max_active_zones 2 || return $SKIP_TESTCASE
+ require_max_open_zones "${max_active_zones}" || return $SKIP_TESTCASE
+ require_seq_zones $((max_active_zones + 1)) || return $SKIP_TESTCASE
+
+ reset_zone "$dev" -1
+
+ # Prepare max_active_zones in open condition.
+ off=$((first_sequential_zone_sector * 512))
+ run_fio --name=w --filename="$dev" --zonemod=zbd --direct=1 \
+ --offset=$((off)) --zonesize="${zone_size}" --rw=randwrite \
+ --bs=4096 --size="$((zone_size * max_active_zones))" \
+ --io_size="${zone_size}" "$(ioengine "psync")" \
+ >> "${logfile}.${test_number}" 2>&1 || return $?
+
+ # Write to antoher zone and trigger max_active_zones limit error.
+ off=$((off + zone_size * max_active_zones))
+ run_one_fio_job --zonemod=zbd --direct=1 "$(ioengine "psync")" \
+ --rw=write --bs=$min_seq_write_size --offset=$((off)) \
+ --size=$((zone_size)) --zonesize="${zone_size}" \
+ >> "${logfile}.${test_number}" 2>&1 && return $?
+ grep -q 'Exceeded max_active_zones limit' "${logfile}.${test_number}"
+}
+
SECONDS=0
tests=()
dynamic_analyzer=()
realsysfs=$(readlink "/sys/dev/block/$major:$minor")
basename=$(basename "${realsysfs%/*}")
fi
- logical_block_size=$(<"/sys/block/$basename/queue/logical_block_size")
+ min_seq_write_size=$(min_seq_write_size "$basename")
case "$(<"/sys/class/block/$basename/queue/zoned")" in
host-managed|host-aware)
is_zbd=true
echo "Failed to determine maximum number of open zones"
exit 1
fi
+ max_active_zones=$(max_active_zones "$dev")
set_io_scheduler "$basename" deadline || exit $?
if [ -n "$reset_all_zones" ]; then
reset_zone "$dev" -1
;;
*)
first_sequential_zone_sector=$(((disk_size / 2) &
- (logical_block_size - 1)))
- zone_size=$(max 65536 "$logical_block_size")
+ (min_seq_write_size - 1)))
+ zone_size=$(max 65536 "$min_seq_write_size")
sectors_per_zone=$((zone_size / 512))
max_open_zones=128
+ max_active_zones=0
set_io_scheduler "$basename" none || exit $?
;;
esac
echo "Failed to determine disk size"
exit 1
fi
- if ! logical_block_size=($(zbc_logical_block_size "$dev")); then
- echo "Failed to determine logical block size"
+ if ! min_seq_write_size=($(zbc_physical_block_size "$dev")); then
+ echo "Failed to determine physical block size"
exit 1
fi
if ! result=($(first_sequential_zone "$dev")); then
echo "Failed to determine maximum number of open zones"
exit 1
fi
+ max_active_zones=0
if [ -n "$reset_all_zones" ]; then
reset_zone "$dev" -1
fi