t/zbd/test-zbd-support

   1 #!/bin/bash
   2 #
   3 # Copyright (C) 2018 Western Digital Corporation or its affiliates.
   4 #
   5 # This file is released under the GPL.
   6
   7 usage() {
   8         echo "Usage: $(basename "$0") [OPTIONS] <test target device file>"
   9         echo "Options:"
  10         echo -e "\t-d Run fio with valgrind using DRD tool"
  11         echo -e "\t-e Run fio with valgrind using helgrind tool"
  12         echo -e "\t-v Run fio with valgrind --read-var-info option"
  13         echo -e "\t-l Test with libzbc ioengine"
  14         echo -e "\t-r Reset all zones before test start"
  15         echo -e "\t-w Reset all zones before executing each write test case"
  16         echo -e "\t-o <max_open_zones> Run fio with max_open_zones limit"
  17         echo -e "\t-t <test #> Run only a single test case with specified number"
  18         echo -e "\t-s <test #> Start testing from the case with the specified number"
  19         echo -e "\t-q Quit the test run after any failed test"
  20         echo -e "\t-z Run fio with debug=zbd option"
  21         echo -e "\t-u Use io_uring ioengine in place of libaio"
  22 }
  23
  24 max() {
  25     if [ "$1" -gt "$2" ]; then
  26         echo "$1"
  27     else
  28         echo "$2"
  29     fi
  30 }
  31
  32 min() {
  33     if [ "$1" -lt "$2" ]; then
  34         echo "$1"
  35     else
  36         echo "$2"
  37     fi
  38 }
  39
  40 ioengine() {
  41         if [ -n "$use_libzbc" ]; then
  42                 echo -n "--ioengine=libzbc"
  43         elif [ "$1" = "libaio" -a -n "$force_io_uring" ]; then
  44                 echo -n "--ioengine=io_uring"
  45         else
  46                 echo -n "--ioengine=$1"
  47         fi
  48 }
  49
  50 get_dev_path_by_id() {
  51         for d in /sys/block/* /sys/block/*/*; do
  52                 if [[ ! -r "${d}/dev" ]]; then
  53                         continue
  54                 fi
  55                 if [[ "${1}" == "$(<"${d}/dev")" ]]; then
  56                         echo "/dev/${d##*/}"
  57                         return 0
  58                 fi
  59         done
  60         return 1
  61 }
  62
  63 dm_destination_dev_set_io_scheduler() {
  64         local dev=$1 sched=$2
  65         local dest_dev_id dest_dev path
  66
  67         has_command dmsetup || return 1
  68
  69         while read -r dest_dev_id; do
  70                 if ! dest_dev=$(get_dev_path_by_id "${dest_dev_id}"); then
  71                         continue
  72                 fi
  73                 path=${dest_dev/dev/sys\/block}/queue/scheduler
  74                 if [[ ! -w ${path} ]]; then
  75                         echo "Can not set scheduler of device mapper destination: ${dest_dev}"
  76                         continue
  77                 fi
  78                 echo "${2}" > "${path}"
  79         done < <(dmsetup table "$(<"/sys/block/$dev/dm/name")" |
  80                          sed -n  's/.* \([0-9]*:[0-9]*\).*/\1/p')
  81 }
  82
  83 dev_has_dm_map() {
  84         local dev=${1} target_type=${2}
  85         local dm_name
  86
  87         has_command dmsetup || return 1
  88
  89         dm_name=$(<"/sys/block/$dev/dm/name")
  90         if ! dmsetup status "${dm_name}" | grep -qe "${target_type}"; then
  91                 return 1
  92         fi
  93         if dmsetup status "${dm_name}" | grep -v "${target_type}"; then
  94                 return 1
  95         fi
  96         return 0
  97 }
  98
  99 set_io_scheduler() {
 100     local dev=$1 sched=$2
 101
 102     [ -e "/sys/block/$dev" ] || return $?
 103     if [ -e "/sys/block/$dev/mq" ]; then
 104         case "$sched" in
 105             noop)        sched=none;;
 106             deadline)    sched=mq-deadline;;
 107         esac
 108     else
 109         case "$sched" in
 110             none)        sched=noop;;
 111             mq-deadline) sched=deadline;;
 112         esac
 113     fi
 114
 115     if [ -w "/sys/block/$dev/queue/scheduler" ]; then
 116         echo "$sched" >"/sys/block/$dev/queue/scheduler"
 117     elif [ -r  "/sys/block/$dev/dm/name" ] &&
 118                  ( dev_has_dm_map "$dev" linear ||
 119                    dev_has_dm_map "$dev" flakey ||
 120                    dev_has_dm_map "$dev" crypt ); then
 121         dm_destination_dev_set_io_scheduler "$dev" "$sched"
 122     else
 123         echo "can not set io scheduler"
 124         exit 1
 125     fi
 126 }
 127
 128 check_read() {
 129     local read
 130
 131     read=$(fio_read <"${logfile}.${test_number}")
 132     echo "read: $read <> $1" >> "${logfile}.${test_number}"
 133     [ "$read" = "$1" ]
 134 }
 135
 136 check_written() {
 137     local written
 138
 139     written=$(fio_written <"${logfile}.${test_number}")
 140     echo "written: $written <> $1" >> "${logfile}.${test_number}"
 141     [ "$written" = "$1" ]
 142 }
 143
 144 # Compare the reset count from the log file with reset count $2 using operator
 145 # $1 (=, -ge, -gt, -le, -lt).
 146 check_reset_count() {
 147     local reset_count
 148
 149     reset_count=$(fio_reset_count <"${logfile}.${test_number}")
 150     echo "reset_count: test $reset_count $1 $2" >> "${logfile}.${test_number}"
 151     eval "[ '$reset_count' '$1' '$2' ]"
 152 }
 153
 154 # Check log for failed assertions and crashes. Without these checks,
 155 # a test can succeed even when these events happen, but it must fail.
 156 check_log() {
 157      [ ! -f "${logfile}.${1}" ] && return 0
 158      ! grep -q -e "Assertion " -e "Aborted " "${logfile}.${1}"
 159 }
 160
 161 # Whether or not $1 (/dev/...) is a SCSI device.
 162 is_scsi_device() {
 163     local d f
 164
 165     d=$(basename "$dev")
 166     for f in /sys/class/scsi_device/*/device/block/"$d"; do
 167         [ -e "$f" ] && return 0
 168     done
 169     return 1
 170 }
 171
 172 job_var_opts_exclude() {
 173         local o
 174         local ex_key="${1}"
 175
 176         for o in "${job_var_opts[@]}"; do
 177                 if [[ ${o} =~ "${ex_key}" ]]; then
 178                         continue
 179                 fi
 180                 echo -n "${o}"
 181         done
 182 }
 183
 184 has_max_open_zones() {
 185         while (($# > 1)); do
 186                 if [[ ${1} =~ "--max_open_zones" ]]; then
 187                         return 0
 188                 fi
 189                 shift
 190         done
 191         return 1
 192 }
 193
 194 run_fio() {
 195     local fio opts
 196
 197     fio=$(dirname "$0")/../../fio
 198
 199     opts=(${global_var_opts[@]})
 200     opts+=("--max-jobs=16" "--aux-path=/tmp" "--allow_file_create=0" \
 201                            "--significant_figures=10" "$@")
 202     # When max_open_zones option is specified to this test script, add
 203     # max_open_zones option to fio command unless the test case already add it.
 204     if [[ -n ${max_open_zones_opt} ]] && ! has_max_open_zones "${opts[@]}"; then
 205             opts+=("--max_open_zones=${max_open_zones_opt}")
 206     fi
 207     { echo; echo "fio ${opts[*]}"; echo; } >>"${logfile}.${test_number}"
 208
 209     "${dynamic_analyzer[@]}" "$fio" "${opts[@]}"
 210 }
 211
 212 run_one_fio_job() {
 213     local r
 214
 215     r=$(((RANDOM << 16) | RANDOM))
 216     run_fio --name="$dev" --filename="$dev" "$@" --randseed="$r"        \
 217             --thread=1 --direct=1
 218 }
 219
 220 write_and_run_one_fio_job() {
 221     local r
 222     local write_offset="${1}"
 223     local write_size="${2}"
 224     local -a write_opts
 225
 226     shift 2
 227     r=$(((RANDOM << 16) | RANDOM))
 228     write_opts=(--name="write_job" --rw=write "$(ioengine "psync")" \
 229                       --bs="${min_seq_write_size}" --zonemode=zbd \
 230                       --zonesize="${zone_size}" --thread=1 --direct=1 \
 231                       --offset="${write_offset}" --size="${write_size}")
 232     write_opts+=("${job_var_opts[@]}")
 233     run_fio --filename="$dev" --randseed="$r" "${write_opts[@]}" \
 234             --name="$dev" --wait_for="write_job" "$@" --thread=1 --direct=1
 235 }
 236
 237 # Run fio on the first four sequential zones of the disk.
 238 run_fio_on_seq() {
 239     local opts=()
 240
 241     opts+=("--offset=$((first_sequential_zone_sector * 512))")
 242     opts+=("--size=$((4 * zone_size))" "--zonemode=zbd")
 243     if [ -z "$is_zbd" ]; then
 244         opts+=("--zonesize=${zone_size}")
 245     fi
 246     run_one_fio_job "${opts[@]}" "$@"
 247 }
 248
 249 # Prepare for write test by resetting zones. When reset_before_write or
 250 # max_open_zones option is specified, reset all zones of the test target to
 251 # ensure that zones out of the test target range do not have open zones. This
 252 # allows the write test to the target range to be able to open zones up to
 253 # max_open_zones limit specified as the option or obtained from sysfs.
 254 prep_write() {
 255         [[ -n "${reset_before_write}" || -n "${max_open_zones_opt}" ]] &&
 256                 [[ -n "${is_zbd}" ]] && reset_zone "${dev}" -1
 257 }
 258
 259 SKIP_TESTCASE=255
 260
 261 require_scsi_dev() {
 262         if ! is_scsi_device "$dev"; then
 263                 SKIP_REASON="$dev is not a SCSI device"
 264                 return 1
 265         fi
 266         return 0
 267 }
 268
 269 require_conv_zone_bytes() {
 270         local req_bytes=${1}
 271
 272         if ((req_bytes > first_sequential_zone_sector * 512)); then
 273                 SKIP_REASON="$dev does not have enough conventional zones"
 274                 return 1
 275         fi
 276         return 0
 277 }
 278
 279 require_zbd() {
 280         if [[ -z ${is_zbd} ]]; then
 281                 SKIP_REASON="$dev is not a zoned block device"
 282                 return 1
 283         fi
 284         return 0
 285 }
 286
 287 require_regular_block_dev() {
 288         if [[ -n ${is_zbd} ]]; then
 289                 SKIP_REASON="$dev is not a regular block device"
 290                 return 1
 291         fi
 292         return 0
 293 }
 294
 295 require_block_dev() {
 296         if [[ -b "$realdev" ]]; then
 297                 return 0
 298         fi
 299         SKIP_REASON="$dev is not a block device"
 300         return 1
 301 }
 302
 303 require_seq_zones() {
 304         local req_seq_zones=${1}
 305         local seq_bytes=$((disk_size - first_sequential_zone_sector * 512))
 306
 307         if ((req_seq_zones > seq_bytes / zone_size)); then
 308                 SKIP_REASON="$dev does not have $req_seq_zones sequential zones"
 309                 return 1
 310         fi
 311         return 0
 312 }
 313
 314 require_conv_zones() {
 315         local req_c_zones=${1}
 316         local conv_bytes=$((first_sequential_zone_sector * 512))
 317
 318         if ((req_c_zones > conv_bytes / zone_size)); then
 319                 SKIP_REASON="$dev does not have $req_c_zones conventional zones"
 320                 return 1
 321         fi
 322         return 0
 323 }
 324
 325 require_max_open_zones() {
 326         local min=${1}
 327
 328         if ((max_open_zones !=0 && max_open_zones < min)); then
 329                 SKIP_REASON="max_open_zones of $dev is smaller than $min"
 330                 return 1
 331         fi
 332         return 0
 333 }
 334
 335 require_max_active_zones() {
 336         local min=${1}
 337
 338         if ((max_active_zones == 0)); then
 339                 SKIP_REASON="$dev does not have max_active_zones limit"
 340                 return 1
 341         fi
 342         if ((max_active_zones < min)); then
 343                 SKIP_REASON="max_active_zones of $dev is smaller than $min"
 344                 return 1
 345         fi
 346         return 0
 347 }
 348
 349 # Check whether buffered writes are refused for block devices.
 350 test1() {
 351     require_block_dev || return $SKIP_TESTCASE
 352     run_fio --name=job1 --filename="$dev" --rw=write --direct=0 --bs=4K \
 353             "$(ioengine "psync")" --size="${zone_size}" --thread=1      \
 354             --zonemode=zbd --zonesize="${zone_size}" 2>&1 |
 355         tee -a "${logfile}.${test_number}" |
 356         grep -q 'Using direct I/O is mandatory for writing to ZBD drives'
 357     local fio_rc=${PIPESTATUS[0]} grep_rc=${PIPESTATUS[2]}
 358     case "$fio_rc" in
 359         0|1) ;;
 360         *)   return "$fio_rc"
 361     esac
 362     if [ -n "$is_zbd" ]; then
 363         [ "$grep_rc" = 0 ]
 364     else
 365         [ "$grep_rc" != 0 ]
 366     fi
 367 }
 368
 369 # Block size exceeds zone size.
 370 test2() {
 371     local bs off opts=() rc
 372
 373     off=$(((first_sequential_zone_sector + 2 * sectors_per_zone) * 512))
 374     bs=$((2 * zone_size))
 375     opts+=("$(ioengine "psync")")
 376     opts+=("--name=job1" "--filename=$dev" "--rw=write" "--direct=1")
 377     opts+=("--zonemode=zbd" "--offset=$off" "--bs=$bs" "--size=$bs")
 378     if [ -z "$is_zbd" ]; then
 379         opts+=("--zonesize=${zone_size}")
 380     fi
 381     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 && return 1
 382     grep -q 'buflen exceeds zone size' "${logfile}.${test_number}"
 383 }
 384
 385 # Run fio against an empty zone. This causes fio to report "No I/O performed".
 386 test3() {
 387     local off opts=() rc
 388
 389     require_seq_zones 129 || return $SKIP_TESTCASE
 390     off=$((first_sequential_zone_sector * 512 + 128 * zone_size))
 391     size=$((zone_size))
 392     [ -n "$is_zbd" ] && reset_zone "$dev" $((off / 512))
 393     opts+=("--name=$dev" "--filename=$dev" "--offset=$off" "--bs=4K")
 394     opts+=("--size=$size" "--zonemode=zbd")
 395     opts+=("$(ioengine "psync")" "--rw=read" "--direct=1" "--thread=1")
 396     if [ -z "$is_zbd" ]; then
 397         opts+=("--zonesize=${zone_size}")
 398     fi
 399     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 400     ! grep -q 'READ:' "${logfile}.${test_number}"
 401 }
 402
 403 # Run fio with --read_beyond_wp=1 against an empty zone.
 404 test4() {
 405     local off opts=()
 406
 407     require_seq_zones 130 || return $SKIP_TESTCASE
 408     off=$((first_sequential_zone_sector * 512 + 129 * zone_size))
 409     size=$((zone_size))
 410     [ -n "$is_zbd" ] && reset_zone "$dev" $((off / 512))
 411     opts+=("--name=$dev" "--filename=$dev" "--offset=$off")
 412     opts+=(--bs="$(min $((min_seq_write_size * 256)) $size)")
 413     opts+=("--size=$size" "--thread=1" "--read_beyond_wp=1")
 414     opts+=("$(ioengine "psync")" "--rw=read" "--direct=1" "--disable_lat=1")
 415     opts+=("--zonemode=zbd" "--zonesize=${zone_size}")
 416     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1
 417     fio_rc=$?
 418     if [[ $unrestricted_reads != 0 ]]; then
 419         if [[ $fio_rc != 0 ]]; then
 420                 return "$fio_rc"
 421         fi
 422         check_read $size || return $?
 423     else
 424         [ $fio_rc == 0 ] && return 1 || return 0
 425     fi
 426 }
 427
 428 # Sequential write to sequential zones.
 429 test5() {
 430     local size off capacity bs
 431
 432     prep_write
 433     off=$((first_sequential_zone_sector * 512))
 434     capacity=$(total_zone_capacity 4 $off $dev)
 435     size=$((4 * zone_size))
 436     bs=$(min "$(max $((zone_size / 64)) "$min_seq_write_size")" "$zone_cap_bs")
 437     run_fio_on_seq "$(ioengine "psync")" --iodepth=1 --rw=write \
 438                    --bs="$bs" --do_verify=1 --verify=md5 \
 439                    >>"${logfile}.${test_number}" 2>&1 || return $?
 440     check_written $capacity || return $?
 441     check_read $capacity || return $?
 442 }
 443
 444 # Sequential read from sequential zones.
 445 test6() {
 446     local size off capacity bs
 447
 448     prep_write
 449     off=$((first_sequential_zone_sector * 512))
 450     capacity=$(total_zone_capacity 4 $off $dev)
 451     size=$((4 * zone_size))
 452     bs=$(min "$(max $((zone_size / 64)) "$min_seq_write_size")" "$zone_cap_bs")
 453     write_and_run_one_fio_job \
 454             $((first_sequential_zone_sector * 512)) "${size}" \
 455             --offset="${off}" \
 456             --size="${size}" --zonemode=zbd --zonesize="${zone_size}" \
 457             "$(ioengine "psync")" --iodepth=1 --rw=read --bs="$bs" \
 458             >>"${logfile}.${test_number}" 2>&1 || return $?
 459     check_read $capacity || return $?
 460 }
 461
 462 # Random write to sequential zones, libaio, queue depth 1.
 463 test7() {
 464     local size=$((zone_size))
 465     local off capacity
 466
 467     prep_write
 468     off=$((first_sequential_zone_sector * 512))
 469     capacity=$(total_zone_capacity 1 $off $dev)
 470     run_fio_on_seq "$(ioengine "libaio")" --iodepth=1 --rw=randwrite    \
 471                    --bs="$(min 16384 "${zone_size}")"                   \
 472                    --do_verify=1 --verify=md5 --size="$size"            \
 473                    >>"${logfile}.${test_number}" 2>&1 || return $?
 474     check_written $capacity || return $?
 475     check_read $capacity || return $?
 476 }
 477
 478 # Random write to sequential zones, libaio, queue depth 64.
 479 test8() {
 480     local size off capacity
 481
 482     prep_write
 483     size=$((4 * zone_size))
 484     off=$((first_sequential_zone_sector * 512))
 485     capacity=$(total_zone_capacity 4 $off $dev)
 486     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite   \
 487                    --bs="$(min 16384 "${zone_size}")"                   \
 488                    --do_verify=1 --verify=md5                           \
 489                    >>"${logfile}.${test_number}" 2>&1 || return $?
 490     check_written $capacity || return $?
 491     check_read $capacity || return $?
 492 }
 493
 494 # Random write to sequential zones, sg, queue depth 1.
 495 test9() {
 496     local size
 497
 498     require_scsi_dev || return $SKIP_TESTCASE
 499
 500     prep_write
 501     size=$((4 * zone_size))
 502     run_fio_on_seq --ioengine=sg                                        \
 503                    --iodepth=1 --rw=randwrite --bs=16K                  \
 504                    --do_verify=1 --verify=md5                           \
 505                    >>"${logfile}.${test_number}" 2>&1 || return $?
 506     check_written $size || return $?
 507     check_read $size || return $?
 508 }
 509
 510 # Random write to sequential zones, sg, queue depth 64.
 511 test10() {
 512     local size
 513
 514     require_scsi_dev || return $SKIP_TESTCASE
 515
 516     prep_write
 517     size=$((4 * zone_size))
 518     run_fio_on_seq --ioengine=sg                                        \
 519                    --iodepth=64 --rw=randwrite --bs=16K                 \
 520                    --do_verify=1 --verify=md5                           \
 521                    >>"${logfile}.${test_number}" 2>&1 || return $?
 522     check_written $size || return $?
 523     check_read $size || return $?
 524 }
 525
 526 # Random write to sequential zones, libaio, queue depth 64, random block size.
 527 test11() {
 528     local size off capacity
 529
 530     prep_write
 531     size=$((4 * zone_size))
 532     off=$((first_sequential_zone_sector * 512))
 533     capacity=$(total_zone_capacity 4 $off $dev)
 534     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite   \
 535                    --bsrange=4K-64K --do_verify=1 --verify=md5          \
 536                    --debug=zbd >>"${logfile}.${test_number}" 2>&1 || return $?
 537     check_written $capacity || return $?
 538     check_read $capacity || return $?
 539 }
 540
 541 # Random write to sequential zones, libaio, queue depth 64, max 1 open zone.
 542 test12() {
 543     local size off capacity
 544
 545     [ -n "$is_zbd" ] && reset_zone "$dev" -1
 546
 547     size=$((8 * zone_size))
 548     off=$((first_sequential_zone_sector * 512))
 549     capacity=$(total_zone_capacity 8 $off $dev)
 550     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite --bs=16K \
 551                    --max_open_zones=1 --size=$size --do_verify=1 --verify=md5 \
 552                    --debug=zbd >>"${logfile}.${test_number}" 2>&1 || return $?
 553     check_written $capacity || return $?
 554     check_read $capacity || return $?
 555 }
 556
 557 # Random write to sequential zones, libaio, queue depth 64, max 4 open zones.
 558 test13() {
 559     local size off capacity
 560
 561     require_max_open_zones 4 || return $SKIP_TESTCASE
 562
 563     [ -n "$is_zbd" ] && reset_zone "$dev" -1
 564
 565     size=$((8 * zone_size))
 566     off=$((first_sequential_zone_sector * 512))
 567     capacity=$(total_zone_capacity 8 $off $dev)
 568     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite --bs=16K \
 569                    --max_open_zones=4 --size=$size --do_verify=1 --verify=md5 \
 570                    --debug=zbd                                                \
 571                    >>"${logfile}.${test_number}" 2>&1 || return $?
 572     check_written $capacity || return $?
 573     check_read $capacity || return $?
 574 }
 575
 576 # Random write to conventional zones.
 577 test14() {
 578     local off size
 579
 580     if ! result=($(first_online_zone "$dev")); then
 581         echo "Failed to determine first online zone"
 582         exit 1
 583     fi
 584     off=${result[0]}
 585     prep_write
 586     size=$((16 * 2**20)) # 20 MB
 587     require_conv_zone_bytes "${size}" || return $SKIP_TESTCASE
 588
 589     run_one_fio_job "$(ioengine "libaio")" --iodepth=64 --rw=randwrite --bs=16K \
 590                     --zonemode=zbd --zonesize="${zone_size}" --do_verify=1 \
 591                     --verify=md5 --offset=$off --size=$size\
 592                     >>"${logfile}.${test_number}" 2>&1 || return $?
 593     check_written $((size)) || return $?
 594     check_read $((size)) || return $?
 595 }
 596
 597 # Sequential read on a mix of empty and full zones.
 598 test15() {
 599     local i off size bs
 600     local w_off w_size w_capacity
 601
 602     for ((i=0;i<4;i++)); do
 603         [ -n "$is_zbd" ] &&
 604             reset_zone "$dev" $((first_sequential_zone_sector +
 605                                  i*sectors_per_zone))
 606     done
 607     prep_write
 608     w_off=$(((first_sequential_zone_sector + 2 * sectors_per_zone) * 512))
 609     w_size=$((2 * zone_size))
 610     w_capacity=$(total_zone_capacity 2 $w_off $dev)
 611     off=$((first_sequential_zone_sector * 512))
 612     size=$((4 * zone_size))
 613     bs=$(min $((zone_size / 16)) "$zone_cap_bs")
 614     write_and_run_one_fio_job "${w_off}" "${w_size}" \
 615                     "$(ioengine "psync")" --rw=read --bs="$bs" \
 616                     --zonemode=zbd --zonesize="${zone_size}" --offset=$off \
 617                     --size=$((size)) >>"${logfile}.${test_number}" 2>&1 ||
 618         return $?
 619     check_written $((w_capacity)) || return $?
 620     check_read $((w_capacity))
 621 }
 622
 623 # Random read on a mix of empty and full zones.
 624 test16() {
 625     local off size
 626     local i w_off w_size w_capacity
 627
 628     for ((i=0;i<4;i++)); do
 629         [ -n "$is_zbd" ] &&
 630             reset_zone "$dev" $((first_sequential_zone_sector +
 631                                  i*sectors_per_zone))
 632     done
 633     prep_write
 634     w_off=$(((first_sequential_zone_sector + 2 * sectors_per_zone) * 512))
 635     w_size=$((2 * zone_size))
 636     w_capacity=$(total_zone_capacity 2 $w_off $dev)
 637     off=$((first_sequential_zone_sector * 512))
 638     size=$((4 * zone_size))
 639     write_and_run_one_fio_job "${w_off}" "${w_size}" \
 640                     "$(ioengine "libaio")" --iodepth=64 --rw=randread --bs=16K \
 641                     --zonemode=zbd --zonesize="${zone_size}" --offset=$off \
 642                     --size=$size >>"${logfile}.${test_number}" 2>&1 || return $?
 643     check_written $w_capacity || return $?
 644     check_read $size || return $?
 645 }
 646
 647 # Random reads and writes in the last zone.
 648 test17() {
 649     local io off last read size written
 650
 651     off=$(((disk_size / zone_size - 1) * zone_size))
 652     size=$((disk_size - off))
 653     if ! last=($(last_online_zone "$dev")); then
 654         echo "Failed to determine last online zone"
 655         exit 1
 656     fi
 657     if [[ "$((last * 512))" -lt "$off" ]]; then
 658         off=$((last * 512))
 659         size=$zone_size
 660     fi
 661     if [ -n "$is_zbd" ]; then
 662         reset_zone "$dev" $((off / 512)) || return $?
 663     fi
 664     prep_write
 665     run_one_fio_job "$(ioengine "libaio")" --iodepth=8 --rw=randrw --bs=4K \
 666                     --zonemode=zbd --zonesize="${zone_size}"            \
 667                     --offset=$off --loops=2 --norandommap=1 \
 668                     --size="$size"\
 669                     >>"${logfile}.${test_number}" 2>&1 || return $?
 670     written=$(fio_written <"${logfile}.${test_number}")
 671     read=$(fio_read <"${logfile}.${test_number}")
 672     io=$((written + read))
 673     echo "Total number of bytes read and written: $io <> $size" \
 674          >>"${logfile}.${test_number}"
 675     [ $io = $((size * 2)) ];
 676 }
 677
 678 # Out-of-range zone reset threshold and frequency parameters.
 679 test18() {
 680     run_fio_on_seq --zone_reset_threshold=-1 |&
 681         tee -a "${logfile}.${test_number}"   |
 682             grep -q 'value out of range' || return $?
 683 }
 684
 685 test19() {
 686     run_fio_on_seq --zone_reset_threshold=2  |&
 687         tee -a "${logfile}.${test_number}"   |
 688         grep -q 'value out of range' || return $?
 689 }
 690
 691 test20() {
 692     run_fio_on_seq --zone_reset_threshold=.4:.6 |&
 693         tee -a "${logfile}.${test_number}"   |
 694         grep -q 'the list exceeding max length' || return $?
 695 }
 696
 697 test21() {
 698     run_fio_on_seq --zone_reset_frequency=-1 |&
 699         tee -a "${logfile}.${test_number}"   |
 700         grep -q 'value out of range' || return $?
 701 }
 702
 703 test22() {
 704     run_fio_on_seq --zone_reset_frequency=2  |&
 705         tee -a "${logfile}.${test_number}"   |
 706         grep -q 'value out of range' || return $?
 707 }
 708
 709 test23() {
 710     run_fio_on_seq --zone_reset_frequency=.4:.6  |&
 711         tee -a "${logfile}.${test_number}"   |
 712         grep -q 'the list exceeding max length' || return $?
 713 }
 714
 715 test24() {
 716     local bs loops=9 size=$((zone_size))
 717     local off capacity
 718
 719     prep_write
 720     off=$((first_sequential_zone_sector * 512))
 721     capacity=$(total_zone_capacity 1 $off $dev)
 722
 723     bs=$(min $((256*1024)) "$zone_size")
 724     run_fio_on_seq "$(ioengine "psync")" --rw=write --bs="$bs"          \
 725                    --size=$size --loops=$loops                          \
 726                    --zone_reset_frequency=.01 --zone_reset_threshold=.90 \
 727                    >> "${logfile}.${test_number}" 2>&1 || return $?
 728     check_written $((capacity * loops)) || return $?
 729     check_reset_count -eq 8 ||
 730         check_reset_count -eq 9 ||
 731         check_reset_count -eq 10 || return $?
 732 }
 733
 734 # Multiple non-overlapping sequential write jobs for the same drive.
 735 test25() {
 736     local i opts=()
 737
 738     for ((i=0;i<16;i++)); do
 739         [ -n "$is_zbd" ] &&
 740             reset_zone "$dev" $((first_sequential_zone_sector + i*sectors_per_zone))
 741     done
 742     prep_write
 743     for ((i=0;i<16;i++)); do
 744         opts+=("--name=job$i" "--filename=$dev" "--thread=1" "--direct=1")
 745         opts+=("--offset=$((first_sequential_zone_sector*512 + zone_size*i))")
 746         opts+=("--size=$zone_size" "$(ioengine "psync")" "--rw=write" "--bs=16K")
 747         opts+=("--zonemode=zbd" "--zonesize=${zone_size}" "--group_reporting=1")
 748         opts+=(${job_var_opts[@]})
 749     done
 750     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 751 }
 752
 753 write_to_first_seq_zone() {
 754     local loops=4 r
 755     local off capacity
 756
 757     prep_write
 758     off=$((first_sequential_zone_sector * 512))
 759     capacity=$(total_zone_capacity 1 $off $dev)
 760
 761     r=$(((RANDOM << 16) | RANDOM))
 762     run_fio --name="$dev" --filename="$dev" "$(ioengine "psync")" --rw="$1" \
 763             --thread=1 --do_verify=1 --verify=md5 --direct=1 --bs=4K    \
 764             --offset=$off                                               \
 765             --size=$zone_size --loops=$loops --randseed="$r"            \
 766             --zonemode=zbd --zonesize="${zone_size}" --group_reporting=1        \
 767             --gtod_reduce=1 >> "${logfile}.${test_number}" 2>&1 || return $?
 768     check_written $((loops * capacity)) || return $?
 769 }
 770
 771 # Overwrite the first sequential zone four times sequentially.
 772 test26() {
 773     write_to_first_seq_zone write
 774 }
 775
 776 # Overwrite the first sequential zone four times using random writes.
 777 test27() {
 778     write_to_first_seq_zone randwrite
 779 }
 780
 781 # Multiple overlapping random write jobs for the same drive.
 782 test28() {
 783     local i jobs=16 off opts
 784
 785     require_seq_zones 65 || return $SKIP_TESTCASE
 786     off=$((first_sequential_zone_sector * 512 + 64 * zone_size))
 787     [ -n "$is_zbd" ] && reset_zone "$dev" $((off / 512))
 788     prep_write
 789     opts=("--debug=zbd")
 790     capacity=$(total_zone_capacity 1 $off $dev)
 791     for ((i=0;i<jobs;i++)); do
 792         opts+=("--name=job$i" "--filename=$dev" "--offset=$off" "--bs=16K")
 793         opts+=("--size=$zone_size" "--io_size=$capacity" "$(ioengine "psync")" "--rw=randwrite")
 794         opts+=("--thread=1" "--direct=1" "--zonemode=zbd")
 795         opts+=("--zonesize=${zone_size}" "--group_reporting=1")
 796         opts+=(${job_var_opts[@]})
 797     done
 798     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 799     check_written $((jobs * $capacity)) || return $?
 800     check_reset_count -eq $jobs ||
 801         check_reset_count -eq $((jobs - 1)) ||
 802         return $?
 803 }
 804
 805 # Multiple overlapping random write jobs for the same drive and with a limited
 806 # number of open zones.
 807 test29() {
 808     local i jobs=16 off opts=()
 809
 810     require_seq_zones 80 || return $SKIP_TESTCASE
 811     off=$((first_sequential_zone_sector * 512 + 64 * zone_size))
 812     size=$((16*zone_size))
 813
 814     [ -n "$is_zbd" ] && reset_zone "$dev" -1
 815
 816     opts=("--debug=zbd")
 817     for ((i=0;i<jobs;i++)); do
 818         opts+=("--name=job$i" "--filename=$dev" "--offset=$off" "--bs=16K")
 819         opts+=("--size=$size" "--io_size=$zone_size" "--thread=1")
 820         opts+=("$(ioengine "psync")" "--rw=randwrite" "--direct=1")
 821         opts+=("--max_open_zones=4" "--group_reporting=1")
 822         opts+=("--zonemode=zbd" "--zonesize=${zone_size}")
 823         # max_open_zones is already specified
 824         opts+=($(job_var_opts_exclude "--max_open_zones"))
 825     done
 826     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 827     check_written $((jobs * zone_size)) || return $?
 828 }
 829
 830 # Random reads and writes across the entire disk for 30s.
 831 test30() {
 832     local off
 833
 834     prep_write
 835     off=$((first_sequential_zone_sector * 512))
 836     run_one_fio_job "$(ioengine "libaio")" --iodepth=8 --rw=randrw      \
 837                     --bs="$(max $((zone_size / 128)) "$min_seq_write_size")"\
 838                     --zonemode=zbd --zonesize="${zone_size}" --offset=$off\
 839                     --loops=2 --time_based --runtime=30s --norandommap=1\
 840                     >>"${logfile}.${test_number}" 2>&1
 841 }
 842
 843 # Random reads across all sequential zones for 30s. This is not only a fio
 844 # test but also allows to verify the performance of a drive.
 845 test31() {
 846     local bs inc nz off opts size
 847
 848     [ -n "$is_zbd" ] && reset_zone "$dev" -1
 849
 850     # As preparation, write 128 KB to sequential write required zones. Limit
 851     # write target zones up to max_open_zones to keep test time reasonable.
 852     # To distribute the write target zones evenly, skip certain zones for every
 853     # write. Utilize zonemode strided for such write patterns.
 854     bs=$((128 * 1024))
 855     off=$((first_sequential_zone_sector * 512))
 856     size=$((disk_size - off))
 857     nz=$((max_open_zones))
 858     if [[ $nz -eq 0 ]]; then
 859         nz=128
 860     fi
 861     if ((size / zone_size < nz)); then
 862         nz=$((size / zone_size))
 863     fi
 864     inc=$(((size / nz / zone_size) * zone_size))
 865     opts=("--name=$dev" "--filename=$dev" "--rw=write" "--bs=${bs}")
 866     opts+=("--offset=$off" "--size=$((inc * nz))" "--io_size=$((bs * nz))")
 867     opts+=("--zonemode=strided" "--zonesize=${bs}" "--zonerange=${inc}")
 868     opts+=("--direct=1" "$(ioengine "psync")")
 869     echo "fio ${opts[@]}" >> "${logfile}.${test_number}"
 870     "$(dirname "$0")/../../fio" "${opts[@]}" >> "${logfile}.${test_number}" \
 871                                 2>&1 || return $?
 872
 873     # Next, run the test.
 874     opts=("--name=$dev" "--filename=$dev" "--offset=$off" "--size=$size")
 875     opts+=("--bs=$bs" "$(ioengine "psync")" "--rw=randread" "--direct=1")
 876     opts+=("--thread=1" "--time_based" "--runtime=30" "--zonemode=zbd")
 877     opts+=("--zonesize=${zone_size}")
 878     opts+=(${job_var_opts[@]})
 879     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 880 }
 881
 882 # Random writes across all sequential zones. This is not only a fio test but
 883 # also allows to verify the performance of a drive.
 884 test32() {
 885     local off opts=() size
 886
 887     require_zbd || return $SKIP_TESTCASE
 888
 889     [ -n "$is_zbd" ] && reset_zone "$dev" -1
 890
 891     off=$((first_sequential_zone_sector * 512))
 892     size=$((disk_size - off))
 893     opts+=("--name=$dev" "--filename=$dev" "--offset=$off" "--size=$size")
 894     opts+=("--bs=128K" "$(ioengine "psync")" "--rw=randwrite" "--direct=1")
 895     opts+=("--thread=1" "--time_based" "--runtime=30")
 896     opts+=("--max_open_zones=$max_open_zones" "--zonemode=zbd")
 897     opts+=("--zonesize=${zone_size}")
 898     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 899 }
 900
 901 # Write to sequential zones with a block size that is not a divisor of the
 902 # zone size.
 903 test33() {
 904     local bs io_size size
 905     local off capacity=0;
 906
 907     [ -n "$is_zbd" ] && reset_zone "$dev" -1
 908
 909     off=$((first_sequential_zone_sector * 512))
 910     capacity=$(total_zone_capacity 1 $off $dev)
 911     size=$((2 * zone_size))
 912     io_size=$((5 * capacity))
 913     bs=$((3 * capacity / 4))
 914     run_fio_on_seq "$(ioengine "psync")" --iodepth=1 --rw=write \
 915                    --size=$size --io_size=$io_size --bs=$bs     \
 916                    >> "${logfile}.${test_number}" 2>&1 || return $?
 917     check_written $((io_size / bs * bs)) || return $?
 918 }
 919
 920 # Test repeated async write job with verify using two unaligned block sizes.
 921 test34() {
 922         local bs off zone_capacity
 923         local -a block_sizes
 924
 925         require_zbd || return $SKIP_TESTCASE
 926         prep_write
 927
 928         off=$((first_sequential_zone_sector * 512))
 929         zone_capacity=$(total_zone_capacity 1 $off $dev)
 930         block_sizes=($((4096 * 7)) $(($(min ${zone_capacity} 4194304) - 4096)))
 931
 932         for bs in ${block_sizes[@]}; do
 933                 run_fio --name=job --filename="${dev}" --rw=randwrite \
 934                         --bs="${bs}" --offset="${off}" \
 935                         --size=$((4 * zone_size)) --iodepth=256 \
 936                         "$(ioengine "libaio")" --time_based=1 --runtime=15s \
 937                         --zonemode=zbd --direct=1 --zonesize="${zone_size}" \
 938                         --verify=crc32c --do_verify=1 ${job_var_opts[@]} \
 939                         >> "${logfile}.${test_number}" 2>&1 || return $?
 940         done
 941 }
 942
 943 # Test 1/4 for the I/O boundary rounding code: $size < $zone_size.
 944 test35() {
 945     local bs off io_size size
 946
 947     prep_write
 948     off=$(((first_sequential_zone_sector + 1) * 512))
 949     size=$((zone_size - 2 * 512))
 950     bs=$((zone_size / 4))
 951     run_one_fio_job --offset=$off --size=$size "$(ioengine "psync")"    \
 952                     --iodepth=1 --rw=write --do_verify=1 --verify=md5   \
 953                     --bs=$bs --zonemode=zbd --zonesize="${zone_size}"   \
 954                     >> "${logfile}.${test_number}" 2>&1 && return 1
 955     grep -q 'io_size must be at least one zone' "${logfile}.${test_number}"
 956 }
 957
 958 # Test 2/4 for the I/O boundary rounding code: $size < $zone_size.
 959 test36() {
 960     local bs off io_size size
 961
 962     prep_write
 963     off=$(((first_sequential_zone_sector) * 512))
 964     size=$((zone_size - 512))
 965     bs=$((zone_size / 4))
 966     run_one_fio_job --offset=$off --size=$size "$(ioengine "psync")"    \
 967                     --iodepth=1 --rw=write --do_verify=1 --verify=md5   \
 968                     --bs=$bs --zonemode=zbd --zonesize="${zone_size}"   \
 969                     >> "${logfile}.${test_number}" 2>&1 && return 1
 970     grep -q 'io_size must be at least one zone' "${logfile}.${test_number}"
 971 }
 972
 973 # Test 3/4 for the I/O boundary rounding code: $size > $zone_size.
 974 test37() {
 975     local bs off size capacity
 976
 977     prep_write
 978     capacity=$(total_zone_capacity 1 $((first_sequential_zone_sector*512)) $dev)
 979     if [ "$first_sequential_zone_sector" = 0 ]; then
 980         off=0
 981     else
 982         off=$(((first_sequential_zone_sector - 1) * 512))
 983     fi
 984     size=$((zone_size + 2 * 512))
 985     bs=$(min $((zone_size / 4)) "$zone_cap_bs")
 986     run_one_fio_job --offset=$off --size=$size "$(ioengine "psync")"    \
 987                     --iodepth=1 --rw=write --do_verify=1 --verify=md5   \
 988                     --bs=$bs --zonemode=zbd --zonesize="${zone_size}"   \
 989                     >> "${logfile}.${test_number}" 2>&1
 990     check_written $capacity || return $?
 991 }
 992
 993 # Test 4/4 for the I/O boundary rounding code: $offset > $disk_size - $zone_size
 994 test38() {
 995     local bs off size
 996
 997     prep_write
 998     size=$((min_seq_write_size))
 999     off=$((disk_size - min_seq_write_size))
1000     bs=$((min_seq_write_size))
1001     run_one_fio_job --offset=$off --size=$size "$(ioengine "psync")"    \
1002                     --iodepth=1 --rw=write --do_verify=1 --verify=md5   \
1003                     --bs=$bs --zonemode=zbd --zonesize="${zone_size}"   \
1004                     >> "${logfile}.${test_number}" 2>&1 && return 1
1005     grep -q 'io_size must be at least one zone' "${logfile}.${test_number}"
1006 }
1007
1008 # Read one block from a block device.
1009 read_one_block() {
1010     local off
1011     local bs
1012
1013     if ! result=($(first_online_zone "$dev")); then
1014         echo "Failed to determine first online zone"
1015         exit 1
1016     fi
1017     off=${result[0]}
1018     bs=$((min_seq_write_size))
1019     run_one_fio_job --rw=read "$(ioengine "psync")" --offset=$off --bs=$bs \
1020                     --size=$bs "$@" 2>&1 |
1021         tee -a "${logfile}.${test_number}"
1022 }
1023
1024 # Check whether fio accepts --zonemode=none for zoned block devices.
1025 test39() {
1026     require_zbd || return $SKIP_TESTCASE
1027     read_one_block --zonemode=none >/dev/null || return $?
1028     check_read $((min_seq_write_size)) || return $?
1029 }
1030
1031 # Check whether fio accepts --zonemode=strided for zoned block devices.
1032 test40() {
1033     local bs
1034
1035     bs=$((min_seq_write_size))
1036     require_zbd || return $SKIP_TESTCASE
1037     read_one_block --zonemode=strided |
1038         grep -q 'fio: --zonesize must be specified when using --zonemode=strided' ||
1039         return $?
1040     read_one_block --zonemode=strided --zonesize=$bs >/dev/null || return $?
1041     check_read $bs || return $?
1042 }
1043
1044 # Check whether fio checks the zone size for zoned block devices.
1045 test41() {
1046     require_zbd || return $SKIP_TESTCASE
1047     read_one_block --zonemode=zbd --zonesize=$((2 * zone_size)) |
1048         grep -q 'job parameter zonesize.*does not match disk zone size'
1049 }
1050
1051 # Check whether fio handles --zonesize=0 correctly for regular block devices.
1052 test42() {
1053     require_regular_block_dev || return $SKIP_TESTCASE
1054     read_one_block --zonemode=zbd --zonesize=0 |
1055         grep -q 'Specifying the zone size is mandatory for regular file/block device with --zonemode=zbd'
1056 }
1057
1058 # Check whether fio handles --zonesize=1 correctly for regular block devices.
1059 test43() {
1060     require_regular_block_dev || return $SKIP_TESTCASE
1061     read_one_block --zonemode=zbd --zonesize=1 |
1062         grep -q 'zone size must be at least 512 bytes for --zonemode=zbd'
1063 }
1064
1065 # Check whether fio handles --zonemode=none --zonesize=1 correctly.
1066 test44() {
1067     read_one_block --zonemode=none --zonesize=1 |
1068         grep -q 'fio: --zonemode=none and --zonesize are not compatible'
1069 }
1070
1071 test45() {
1072     local bs i
1073     local grep_str="fio: first I/O failed. If .* is a zoned block device, consider --zonemode=zbd"
1074
1075     require_zbd || return $SKIP_TESTCASE
1076     prep_write
1077     bs=$((min_seq_write_size))
1078     for ((i = 0; i < 10; i++)); do
1079             run_one_fio_job "$(ioengine "psync")" --iodepth=1 --rw=randwrite \
1080                             --offset=$((first_sequential_zone_sector * 512)) \
1081                             --bs="$bs" --time_based --runtime=1s \
1082                             --do_verify=1 --verify=md5 \
1083                     >> "${logfile}.${test_number}" 2>&1
1084             grep -qe "$grep_str" "${logfile}.${test_number}" && return 0
1085     done
1086     return 1
1087 }
1088
1089 # Random write to sequential zones, libaio, 8 jobs, queue depth 64 per job
1090 test46() {
1091     local size
1092
1093     prep_write
1094     size=$((4 * zone_size))
1095     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite --bs=4K \
1096                    --group_reporting=1 --numjobs=8 \
1097                    >> "${logfile}.${test_number}" 2>&1 || return $?
1098     check_written $((size * 8)) || return $?
1099 }
1100
1101 # Check whether fio handles --zonemode=zbd --zoneskip=1 correctly.
1102 test47() {
1103     local bs
1104
1105     prep_write
1106     bs=$((min_seq_write_size))
1107     run_fio_on_seq "$(ioengine "psync")" --rw=write --bs=$bs --zoneskip=1 \
1108                     >> "${logfile}.${test_number}" 2>&1 && return 1
1109     grep -q 'zoneskip 1 is not a multiple of the device zone size' "${logfile}.${test_number}"
1110 }
1111
1112 # Multiple overlapping random write jobs for the same drive and with a
1113 # limited number of open zones. This is similar to test29, but uses libaio
1114 # to stress test zone locking.
1115 test48() {
1116     local i jobs=16 off opts=()
1117
1118     require_zbd || return $SKIP_TESTCASE
1119     require_seq_zones 80 || return $SKIP_TESTCASE
1120
1121     off=$((first_sequential_zone_sector * 512 + 64 * zone_size))
1122     size=$((16*zone_size))
1123
1124     [ -n "$is_zbd" ] && reset_zone "$dev" -1
1125
1126     opts=("--aux-path=/tmp" "--allow_file_create=0" "--significant_figures=10")
1127     opts+=("--debug=zbd")
1128     opts+=("$(ioengine "libaio")" "--rw=randwrite" "--direct=1")
1129     opts+=("--time_based" "--runtime=30")
1130     opts+=("--zonemode=zbd" "--zonesize=${zone_size}")
1131     opts+=("--max_open_zones=4")
1132     for ((i=0;i<jobs;i++)); do
1133         opts+=("--name=job$i" "--filename=$dev" "--offset=$off" "--bs=16K")
1134         opts+=("--io_size=$zone_size" "--iodepth=256" "--thread=1")
1135         opts+=("--size=$size" "--group_reporting=1")
1136         # max_open_zones is already specified
1137         opts+=($(job_var_opts_exclude "--max_open_zones"))
1138     done
1139
1140     fio=$(dirname "$0")/../../fio
1141
1142     { echo; echo "fio ${opts[*]}"; echo; } >>"${logfile}.${test_number}"
1143
1144     timeout -v -s KILL 180s \
1145             "${dynamic_analyzer[@]}" "$fio" "${opts[@]}" \
1146             >> "${logfile}.${test_number}" 2>&1 || return $?
1147 }
1148
1149 # Check if fio handles --zonecapacity on a normal block device correctly
1150 test49() {
1151
1152     require_regular_block_dev || return $SKIP_TESTCASE
1153
1154     size=$((2 * zone_size))
1155     capacity=$((zone_size * 3 / 4))
1156
1157     run_one_fio_job "$(ioengine "psync")" --rw=write \
1158                     --zonemode=zbd --zonesize="${zone_size}" \
1159                     --zonecapacity=${capacity} \
1160                     --verify=md5  --size=${size} >>"${logfile}.${test_number}" 2>&1 ||
1161         return $?
1162     check_written $((capacity * 2)) || return $?
1163     check_read $((capacity * 2)) || return $?
1164 }
1165
1166 # Verify that conv zones are not locked and only seq zones are locked during
1167 # random read on conv-seq mixed zones.
1168 test50() {
1169         local off
1170
1171         require_zbd || return $SKIP_TESTCASE
1172         require_conv_zones 8 || return $SKIP_TESTCASE
1173         require_seq_zones 8 || return $SKIP_TESTCASE
1174
1175         reset_zone "${dev}" -1
1176
1177         off=$((first_sequential_zone_sector * 512 - 8 * zone_size))
1178         run_fio --name=job --filename=${dev} --offset=${off} --bs=64K \
1179                 --size=$((16 * zone_size)) "$(ioengine "libaio")" --rw=randread\
1180                 --time_based --runtime=3 --zonemode=zbd --zonesize=${zone_size}\
1181                 --direct=1 --group_reporting=1 ${job_var_opts[@]} \
1182                 >> "${logfile}.${test_number}" 2>&1 || return $?
1183 }
1184
1185 # Verify that conv zones are neither locked nor opened during random write on
1186 # conv-seq mixed zones. Zone lock and zone open shall happen only on seq zones.
1187 test51() {
1188         local off jobs=16
1189         local -a opts
1190
1191         require_zbd || return $SKIP_TESTCASE
1192         require_conv_zones 8 || return $SKIP_TESTCASE
1193         require_seq_zones 8 || return $SKIP_TESTCASE
1194
1195         reset_zone "$dev" -1
1196
1197         off=$((first_sequential_zone_sector * 512 - 8 * zone_size))
1198         opts+=("--size=$((16 * zone_size))" "$(ioengine "libaio")")
1199         opts+=("--zonemode=zbd" "--direct=1" "--zonesize=${zone_size}")
1200         opts+=("--max_open_zones=2" "--offset=$off")
1201         opts+=("--thread=1" "--group_reporting=1")
1202         opts+=("--time_based" "--runtime=30" "--rw=randwrite")
1203         for ((i=0;i<jobs;i++)); do
1204                 opts+=("--name=job${i}" "--filename=$dev")
1205                 opts+=("--bs=$(((i+1)*16))K")
1206                 opts+=($(job_var_opts_exclude "--max_open_zones"))
1207         done
1208         run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
1209 }
1210
1211 # Verify that zone_reset_threshold only accounts written bytes in seq
1212 # zones, and written data bytes of conv zones are not counted.
1213 test52() {
1214         local off io_size
1215
1216         require_zbd || return $SKIP_TESTCASE
1217         require_conv_zones 8 || return $SKIP_TESTCASE
1218         require_seq_zones 8 || return $SKIP_TESTCASE
1219
1220         reset_zone "${dev}" -1
1221
1222         # Total I/O size is 1/8 = 0.125 of the I/O range of cont + seq zones.
1223         # Set zone_reset_threshold as 0.1. The threshold size is less than
1224         # 0.125, then, reset count zero is expected.
1225         # On the other hand, half of the I/O range is covered by conv zones.
1226         # If fio would count the conv zones for zone_reset_threshold, the ratio
1227         # were more than 0.5 and would trigger zone resets.
1228
1229         off=$((first_sequential_zone_sector * 512 - 8 * zone_size))
1230         io_size=$((zone_size * 16 / 8))
1231         run_fio --name=job --filename=$dev --rw=randwrite --bs=$((zone_size/16))\
1232                 --size=$((zone_size * 16)) --softrandommap=1 \
1233                 --io_size=$((io_size)) "$(ioengine "psync")" --offset=$off \
1234                 --zonemode=zbd --direct=1 --zonesize=${zone_size} \
1235                 --zone_reset_threshold=.1 --zone_reset_frequency=1.0 \
1236                 ${job_var_opts[@]} --debug=zbd \
1237                 >> "${logfile}.${test_number}" 2>&1 || return $?
1238
1239         check_written ${io_size} || return $?
1240         check_reset_count -eq 0 || return $?
1241 }
1242
1243 # Check both reads and writes are executed by random I/O to conventional zones.
1244 test53() {
1245         local off capacity io read_b=0 written_b=0
1246
1247         require_zbd || return $SKIP_TESTCASE
1248         require_conv_zones 4 || return $SKIP_TESTCASE
1249
1250         off=$((first_sequential_zone_sector * 512 - 4 * zone_size))
1251         capacity=$(total_zone_capacity 4 $off $dev)
1252         run_fio --name=job --filename=${dev} --rw=randrw --bs=64K \
1253                 --size=$((4 * zone_size)) "$(ioengine "psync")" --offset=${off}\
1254                 --zonemode=zbd --direct=1 --zonesize=${zone_size} \
1255                 ${job_var_opts[@]} \
1256                 >> "${logfile}.${test_number}" 2>&1 || return $?
1257
1258         written_b=$(fio_written <"${logfile}.${test_number}")
1259         read_b=$(fio_read <"${logfile}.${test_number}")
1260         io=$((written_b + read_b))
1261         echo "Number of bytes read: $read_b" >>"${logfile}.${test_number}"
1262         echo "Number of bytes written: $written_b" >>"${logfile}.${test_number}"
1263         echo "Total number of bytes read and written: $io <> $capacity" \
1264              >>"${logfile}.${test_number}"
1265         if ((io==capacity && written_b != 0 && read_b != 0)); then
1266                 return 0
1267         fi
1268         return 1
1269 }
1270
1271 # Test read/write mix with verify.
1272 test54() {
1273         require_zbd || return $SKIP_TESTCASE
1274         require_seq_zones 8 || return $SKIP_TESTCASE
1275
1276         prep_write
1277         run_fio --name=job --filename=${dev} "$(ioengine "libaio")" \
1278                 --time_based=1 --runtime=30s --continue_on_error=0 \
1279                 --offset=$((first_sequential_zone_sector * 512)) \
1280                 --size=$((8*zone_size)) --direct=1 --iodepth=1 \
1281                 --rw=randrw:2 --rwmixwrite=25 --bsrange=4k-${zone_size} \
1282                 --zonemode=zbd --zonesize=${zone_size} \
1283                 --verify=crc32c --do_verify=1 --verify_backlog=2 \
1284                 --alloc-size=65536 --random_generator=tausworthe64 \
1285                 ${job_var_opts[@]} --debug=zbd \
1286                 >> "${logfile}.${test_number}" 2>&1 || return $?
1287 }
1288
1289 # test 'z' suffix parsing only
1290 test55() {
1291         local bs
1292         bs=$((min_seq_write_size))
1293
1294         require_zbd || return $SKIP_TESTCASE
1295         # offset=1z + offset_increment=10z + size=2z
1296         require_seq_zones 13 || return $SKIP_TESTCASE
1297
1298         prep_write
1299         run_fio --name=j                \
1300                 --filename=${dev}       \
1301                 --direct=1              \
1302                 "$(ioengine "psync")"   \
1303                 --zonemode=zbd          \
1304                 --zonesize=${zone_size} \
1305                 --rw=write              \
1306                 --bs=${bs}              \
1307                 --numjobs=2             \
1308                 --offset_increment=10z  \
1309                 --offset=1z             \
1310                 --size=2z               \
1311                 --io_size=3z            \
1312                 ${job_var_opts[@]} --debug=zbd \
1313                 >> "${logfile}.${test_number}" 2>&1 || return $?
1314 }
1315
1316 # test 'z' suffix parsing only
1317 test56() {
1318         local bs
1319         bs=$((min_seq_write_size))
1320
1321         require_regular_block_dev || return $SKIP_TESTCASE
1322         require_seq_zones 10 || return $SKIP_TESTCASE
1323
1324         prep_write
1325         run_fio --name=j                \
1326                 --filename=${dev}       \
1327                 --direct=1              \
1328                 "$(ioengine "psync")"   \
1329                 --zonemode=strided      \
1330                 --zonesize=${zone_size} \
1331                 --rw=write              \
1332                 --bs=${bs}              \
1333                 --size=10z              \
1334                 --zoneskip=2z           \
1335                 ${job_var_opts[@]} --debug=zbd \
1336                 >> "${logfile}.${test_number}" 2>&1 || return $?
1337 }
1338
1339 # Test that repeated async write job does not cause zone reset during writes
1340 # in-flight, when the block size is not a divisor of the zone size.
1341 test57() {
1342         local bs off
1343
1344         require_zbd || return $SKIP_TESTCASE
1345
1346         prep_write
1347         bs=$((4096 * 7))
1348         off=$((first_sequential_zone_sector * 512))
1349
1350         run_fio --name=job --filename="${dev}" --rw=randwrite --bs="${bs}" \
1351                 --offset="${off}" --size=$((4 * zone_size)) --iodepth=256 \
1352                 "$(ioengine "libaio")" --time_based=1 --runtime=30s \
1353                 --zonemode=zbd --direct=1 --zonesize="${zone_size}" \
1354                 ${job_var_opts[@]} \
1355                 >> "${logfile}.${test_number}" 2>&1 || return $?
1356 }
1357
1358 # Random writes and random trims to sequential write required zones for 30s.
1359 test58() {
1360     local off size bs
1361
1362     require_seq_zones 128 || return $SKIP_TESTCASE
1363
1364     size=$((zone_size * 128))
1365     bs="$(max $((zone_size / 128)) "$min_seq_write_size")"
1366     prep_write
1367     off=$((first_sequential_zone_sector * 512))
1368     run_fio --zonemode=zbd --direct=1 --zonesize="${zone_size}" --thread=1 \
1369             --filename="${dev}" --norandommap=1 \
1370             --name="precondition"  --rw=write "$(ioengine "psync")" \
1371             --offset="${off}" --size=$((zone_size * 16)) --bs="${bs}" \
1372             "${job_var_opts[@]}" \
1373             --name=wjob --wait_for="precondition" --rw=randwrite \
1374             "$(ioengine "libaio")" --iodepth=8 \
1375             --offset="${off}" --size="${size}" --bs="${bs}" \
1376             --time_based --runtime=30s --flow=128 "${job_var_opts[@]}" \
1377             --name=trimjob --wait_for="precondition" --rw=randtrim \
1378             "$(ioengine "psync")" \
1379             --offset="${off}" --size="${size}" --bs="${zone_size}" \
1380             --time_based --runtime=30s --flow=1 "${job_var_opts[@]}" \
1381             >>"${logfile}.${test_number}" 2>&1
1382 }
1383
1384 # Test zone_reset_threshold with verify.
1385 test59() {
1386         local off bs loops=2 size=$((zone_size)) w
1387         local -a workloads=(write randwrite rw randrw)
1388
1389         prep_write
1390         off=$((first_sequential_zone_sector * 512))
1391
1392         bs=$(min $((256*1024)) "$zone_size")
1393         for w in "${workloads[@]}"; do
1394                 run_fio_on_seq "$(ioengine "psync")" --rw=${w} --bs="$bs" \
1395                                --size=$size --loops=$loops --do_verify=1 \
1396                                --verify=md5 --zone_reset_frequency=.9 \
1397                                --zone_reset_threshold=.1 \
1398                                >> "${logfile}.${test_number}" 2>&1 || return $?
1399         done
1400 }
1401
1402 # Test fio errors out experimental_verify option with zonemode=zbd.
1403 test60() {
1404         run_fio_on_seq "$(ioengine "psync")" --rw=write --size=$zone_size \
1405                        --do_verify=1 --verify=md5 --experimental_verify=1 \
1406                        >> "${logfile}.${test_number}" 2>&1 && return 1
1407         grep -q 'not support experimental verify' "${logfile}.${test_number}"
1408 }
1409
1410 # Test fio errors out zone_reset_threshold option for multiple jobs with
1411 # different write ranges.
1412 test61() {
1413         run_fio_on_seq "$(ioengine "psync")" --rw=write --size="$zone_size" \
1414                        --numjobs=2 --offset_increment="$zone_size" \
1415                        --zone_reset_threshold=0.1 --zone_reset_frequency=1 \
1416                        --exitall_on_error=1 \
1417                        >> "${logfile}.${test_number}" 2>&1 && return 1
1418         grep -q 'different write ranges' "${logfile}.${test_number}"
1419 }
1420
1421 # Test zone_reset_threshold option works for multiple jobs with same write
1422 # range.
1423 test62() {
1424         local bs loops=2 size=$((zone_size))
1425
1426         [ -n "$is_zbd" ] && reset_zone "$dev" -1
1427
1428         # Two jobs write to single zone twice. Reset zone happens at next write
1429         # after half of the zone gets filled. So 2 * 2 * 2 - 1 = 7 times zone
1430         # resets are expected.
1431         bs=$(min $((256*1024)) $((zone_size / 4)))
1432         run_fio_on_seq "$(ioengine "psync")" --rw=write --bs="$bs" \
1433                        --size=$size --loops=$loops --numjobs=2 \
1434                        --zone_reset_frequency=1 --zone_reset_threshold=.5 \
1435                        --group_reporting=1 \
1436                        >> "${logfile}.${test_number}" 2>&1 || return $?
1437         check_written $((size * loops * 2)) || return $?
1438         check_reset_count -eq 7 || return $?
1439 }
1440
1441 # Test zone_reset_threshold option works for a read job and a write job with
1442 # different IO range.
1443 test63() {
1444         local bs loops=2 size=$((zone_size)) off1 off2
1445
1446         [ -n "$is_zbd" ] && reset_zone "$dev" -1
1447
1448         off1=$((first_sequential_zone_sector * 512))
1449         off2=$((off1 + zone_size))
1450         bs=$(min $((256*1024)) $((zone_size / 4)))
1451
1452         # One job writes to single zone twice. Reset zone happens at next write
1453         # after half of the zone gets filled. So 2 * 2 - 1 = 3 times zone resets
1454         # are expected.
1455         run_fio "$(ioengine "psync")" --bs="$bs" --size=$size --loops=$loops \
1456                 --filename="$dev" --group_reporting=1 \
1457                 --zonemode=zbd --zonesize="$zone_size" --direct=1 \
1458                 --zone_reset_frequency=1 --zone_reset_threshold=.5 \
1459                 --name=r --rw=read --offset=$off1 "${job_var_opts[@]}" \
1460                 --name=w --rw=write --offset=$off2 "${job_var_opts[@]}" \
1461                        >> "${logfile}.${test_number}" 2>&1 || return $?
1462         check_written $((size * loops)) || return $?
1463         check_reset_count -eq 3 || return $?
1464 }
1465
1466 # Test write zone accounting handles almost full zones correctly. Prepare an
1467 # almost full, but not full zone. Write to the zone with verify using larger
1468 # block size. Then confirm fio does not report write zone accounting failure.
1469 test64() {
1470         local bs cap
1471
1472         [ -n "$is_zbd" ] && reset_zone "$dev" -1
1473
1474         bs=$((zone_size / 8))
1475         cap=$(total_zone_capacity 1 $((first_sequential_zone_sector*512)) $dev)
1476         run_fio_on_seq "$(ioengine "psync")" --rw=write --bs="$bs" \
1477                        --size=$((zone_size)) \
1478                        --io_size=$((cap - bs)) \
1479                        >> "${logfile}.${test_number}" 2>&1 || return $?
1480
1481         bs=$((zone_size / 2))
1482         run_fio_on_seq "$(ioengine "psync")" --rw=write --bs="$bs" \
1483                        --size=$((zone_size)) --do_verify=1 --verify=md5 \
1484                        >> "${logfile}.${test_number}" 2>&1 || return $?
1485 }
1486
1487 # Test open zone accounting handles trim workload correctly. Prepare open zones
1488 # as many as max_open_zones=4. Trim one of the 4 zones. Then write to another
1489 # zone and check the write amount is expected size.
1490 test65() {
1491         local off capacity
1492
1493         [ -n "$is_zbd" ] && reset_zone "$dev" -1
1494
1495         off=$((first_sequential_zone_sector * 512))
1496         capacity=$(total_zone_capacity 1 $off "$dev")
1497         run_fio --zonemode=zbd --direct=1 --zonesize="$zone_size" --thread=1 \
1498                 --filename="$dev" --group_reporting=1 --max_open_zones=4 \
1499                 "$(ioengine "psync")" \
1500                 --name="prep_open_zones" --rw=randwrite --offset="$off" \
1501                 --size="$((zone_size * 4))" --bs=4096 --io_size="$zone_size" \
1502                 --name=trimjob --wait_for="prep_open_zones" --rw=trim \
1503                 --bs="$zone_size" --offset="$off" --size="$zone_size" \
1504                 --name=write --wait_for="trimjob" --rw=write --bs=4096 \
1505                 --offset="$((off + zone_size * 4))" --size="$zone_size" \
1506                 >> "${logfile}.${test_number}" 2>&1
1507
1508         check_written $((zone_size + capacity))
1509 }
1510
1511 # Test closed zones are handled as open zones. This test case requires zoned
1512 # block devices which has same max_open_zones and max_active_zones.
1513 test66() {
1514         local i off
1515
1516         require_zbd || return $SKIP_TESTCASE
1517         require_max_active_zones 2 || return $SKIP_TESTCASE
1518         require_max_open_zones "${max_active_zones}" || return $SKIP_TESTCASE
1519         require_seq_zones $((max_active_zones * 16)) || return $SKIP_TESTCASE
1520
1521         reset_zone "$dev" -1
1522
1523         # Prepare max_active_zones in closed condition.
1524         off=$((first_sequential_zone_sector * 512))
1525         run_fio --name=w --filename="$dev" --zonemod=zbd --direct=1 \
1526                 --offset=$((off)) --zonesize="${zone_size}" --rw=randwrite \
1527                 --bs=4096 --size="$((zone_size * max_active_zones))" \
1528                 --io_size="${zone_size}" "$(ioengine "psync")" \
1529                 >> "${logfile}.${test_number}" 2>&1 || return $?
1530         for ((i = 0; i < max_active_zones; i++)); do
1531                 close_zone "$dev" $((off / 512)) || return $?
1532                 off=$((off + zone_size))
1533         done
1534
1535         # Run random write to the closed zones and empty zones. This confirms
1536         # that fio handles closed zones as write target open zones. Otherwise,
1537         # fio writes to the empty zones and hit the max_active_zones limit.
1538         off=$((first_sequential_zone_sector * 512))
1539         run_one_fio_job --zonemod=zbd --direct=1 \
1540                        "$(ioengine "psync")" --rw=randwrite --bs=4096 \
1541                        --max_open_zones="$max_active_zones" --offset=$((off)) \
1542                        --size=$((max_active_zones * 16 * zone_size)) \
1543                        --io_size=$((zone_size)) --zonesize="${zone_size}" \
1544                        --time_based --runtime=5s \
1545                        >> "${logfile}.${test_number}" 2>&1
1546 }
1547
1548 # Test max_active_zones limit failure is reported with good error message.
1549 test67() {
1550         local i off
1551
1552         require_zbd || return $SKIP_TESTCASE
1553         require_max_active_zones 2 || return $SKIP_TESTCASE
1554         require_max_open_zones "${max_active_zones}" || return $SKIP_TESTCASE
1555         require_seq_zones $((max_active_zones + 1)) || return $SKIP_TESTCASE
1556
1557         reset_zone "$dev" -1
1558
1559         # Prepare max_active_zones in open condition.
1560         off=$((first_sequential_zone_sector * 512))
1561         run_fio --name=w --filename="$dev" --zonemod=zbd --direct=1 \
1562                 --offset=$((off)) --zonesize="${zone_size}" --rw=randwrite \
1563                 --bs=4096 --size="$((zone_size * max_active_zones))" \
1564                 --io_size="${zone_size}" "$(ioengine "psync")" \
1565                 >> "${logfile}.${test_number}" 2>&1 || return $?
1566
1567         # Write to antoher zone and trigger max_active_zones limit error.
1568         off=$((off + zone_size * max_active_zones))
1569         run_one_fio_job --zonemod=zbd --direct=1 "$(ioengine "psync")" \
1570                         --rw=write --bs=$min_seq_write_size --offset=$((off)) \
1571                         --size=$((zone_size)) --zonesize="${zone_size}" \
1572                         >> "${logfile}.${test_number}" 2>&1 && return $?
1573         grep -q 'Exceeded max_active_zones limit' "${logfile}.${test_number}"
1574 }
1575
1576 # Test rw=randrw and rwmixwrite=0 options do not issue write I/O unit
1577 test68() {
1578         local off size
1579
1580         require_zbd || return "$SKIP_TESTCASE"
1581
1582         reset_zone "${dev}" -1
1583
1584         # Write some data as preparation
1585         off=$((first_sequential_zone_sector * 512))
1586         size=$min_seq_write_size
1587         run_one_fio_job "$(ioengine "psync")" --rw=write --offset="$off" \
1588                         --io_size="$size" --zonemode=strided \
1589                         --zonesize="$zone_size" --zonerange="$zone_size" \
1590                        >> "${logfile}.${test_number}" 2>&1 || return $?
1591         # Run random mixed read and write specifying zero write ratio
1592         run_fio_on_seq "$(ioengine "psync")" --rw=randrw --rwmixwrite=0 \
1593                        --time_based --runtime=1s \
1594                        >> "${logfile}.${test_number}" 2>&1 || return $?
1595         # "WRITE:" shall be recoreded only once for the preparation
1596         [[ $(grep -c "WRITE:" "${logfile}.${test_number}") == 1 ]]
1597 }
1598
1599 # Test rw=rw and verify_backlog=1 options do not cause verify failure
1600 test69() {
1601         require_zbd || return "$SKIP_TESTCASE"
1602
1603         prep_write
1604         run_fio --name=job --filename="$dev" --time_based --runtime=15s \
1605                 --rw=rw --offset=$((first_sequential_zone_sector * 512)) \
1606                 "$(ioengine "libaio")" --iodepth=32 --randrepeat=0 \
1607                 --verify=crc32 --verify_backlog=1 --zonemode=zbd --direct=1 \
1608                 >> "${logfile}.${test_number}" 2>&1 || return $?
1609 }
1610
1611 SECONDS=0
1612 tests=()
1613 dynamic_analyzer=()
1614 reset_all_zones=
1615 reset_before_write=
1616 use_libzbc=
1617 zbd_debug=
1618 max_open_zones_opt=
1619 quit_on_err=
1620 force_io_uring=
1621 start_test=1
1622
1623 while [ "${1#-}" != "$1" ]; do
1624   case "$1" in
1625     -d) dynamic_analyzer=(valgrind "--read-var-info=yes" "--tool=drd"
1626                           "--show-confl-seg=no");
1627         shift;;
1628     -e) dynamic_analyzer=(valgrind "--read-var-info=yes" "--tool=helgrind");
1629         shift;;
1630     -l) use_libzbc=1; shift;;
1631     -r) reset_all_zones=1; shift;;
1632     -w) reset_before_write=1; shift;;
1633     -t) tests+=("$2"); shift; shift;;
1634     -o) max_open_zones_opt="${2}"; shift; shift;;
1635     -s) start_test=$2; shift; shift;;
1636     -v) dynamic_analyzer=(valgrind "--read-var-info=yes");
1637         shift;;
1638     -q) quit_on_err=1; shift;;
1639     -z) zbd_debug=1; shift;;
1640     -u) force_io_uring=1; shift;;
1641     --) shift; break;;
1642      *) usage; exit 1;;
1643   esac
1644 done
1645
1646 if [ $# != 1 ]; then
1647     usage
1648     exit 1
1649 fi
1650
1651 if [ -n "$use_libzbc" -a -n "$force_io_uring" ]; then
1652     echo "Please specify only one of -l and -u options"
1653     exit 1
1654 fi
1655
1656 # shellcheck source=functions
1657 source "$(dirname "$0")/functions" || exit $?
1658
1659 global_var_opts=()
1660 job_var_opts=()
1661 if [ -n "$zbd_debug" ]; then
1662     global_var_opts+=("--debug=zbd")
1663 fi
1664 dev=$1
1665 realdev=$(readlink -f "$dev")
1666 basename=$(basename "$realdev")
1667
1668 if [[ -b "$realdev" ]]; then
1669         major=$((0x$(stat -L -c '%t' "$realdev"))) || exit $?
1670         minor=$((0x$(stat -L -c '%T' "$realdev"))) || exit $?
1671         disk_size=$(($(<"/sys/dev/block/$major:$minor/size")*512))
1672
1673         # When the target is a partition device, get basename of its
1674         # holder device to access sysfs path of the holder device
1675         if [[ -r "/sys/dev/block/$major:$minor/partition" ]]; then
1676                 realsysfs=$(readlink "/sys/dev/block/$major:$minor")
1677                 basename=$(basename "${realsysfs%/*}")
1678         fi
1679         min_seq_write_size=$(min_seq_write_size "$basename")
1680         case "$(<"/sys/class/block/$basename/queue/zoned")" in
1681         host-managed|host-aware)
1682                 is_zbd=true
1683                 if ! check_blkzone "${dev}"; then
1684                         exit 1
1685                 fi
1686                 if ! result=($(first_sequential_zone "$dev")); then
1687                         echo "Failed to determine first sequential zone"
1688                         exit 1
1689                 fi
1690                 first_sequential_zone_sector=${result[0]}
1691                 sectors_per_zone=${result[1]}
1692                 zone_size=$((sectors_per_zone * 512))
1693                 unrestricted_reads=$(urswrz "$dev")
1694                 if ! max_open_zones=$(max_open_zones "$dev"); then
1695                         echo "Failed to determine maximum number of open zones"
1696                         exit 1
1697                 fi
1698                 max_active_zones=$(max_active_zones "$dev")
1699                 set_io_scheduler "$basename" deadline || exit $?
1700                 if [ -n "$reset_all_zones" ]; then
1701                         reset_zone "$dev" -1
1702                 fi
1703                 ;;
1704         *)
1705                 first_sequential_zone_sector=$(((disk_size / 2) &
1706                                                 (min_seq_write_size - 1)))
1707                 zone_size=$(max 65536 "$min_seq_write_size")
1708                 sectors_per_zone=$((zone_size / 512))
1709                 max_open_zones=128
1710                 max_active_zones=0
1711                 unrestricted_reads=1
1712                 set_io_scheduler "$basename" none || exit $?
1713                 ;;
1714         esac
1715
1716 elif [[ -c "$realdev" ]]; then
1717         # For an SG node, we must have libzbc option specified
1718         if [[ ! -n "$use_libzbc" ]]; then
1719                 echo "Character device files can only be used with -l (libzbc) option"
1720                 exit 1
1721         fi
1722
1723         if ! $(is_zbc "$dev"); then
1724                 echo "Device is not a ZBC disk"
1725                 exit 1
1726         fi
1727         is_zbd=true
1728
1729         if ! disk_size=($(( $(zbc_disk_sectors "$dev") * 512))); then
1730                 echo "Failed to determine disk size"
1731                 exit 1
1732         fi
1733         if ! min_seq_write_size=($(zbc_physical_block_size "$dev")); then
1734                 echo "Failed to determine physical block size"
1735                 exit 1
1736         fi
1737         if ! result=($(first_sequential_zone "$dev")); then
1738                 echo "Failed to determine first sequential zone"
1739                 exit 1
1740         fi
1741         first_sequential_zone_sector=${result[0]}
1742         sectors_per_zone=${result[1]}
1743         zone_size=$((sectors_per_zone * 512))
1744         unrestricted_reads=$(urswrz "$dev")
1745         if ! max_open_zones=$(max_open_zones "$dev"); then
1746                 echo "Failed to determine maximum number of open zones"
1747                 exit 1
1748         fi
1749         max_active_zones=0
1750         if [ -n "$reset_all_zones" ]; then
1751                 reset_zone "$dev" -1
1752         fi
1753 fi
1754
1755 if [[ -n ${max_open_zones_opt} ]]; then
1756         # Override max_open_zones with the script option value
1757         max_open_zones="${max_open_zones_opt}"
1758         global_var_opts+=("--ignore_zone_limits=1")
1759         job_var_opts+=("--max_open_zones=${max_open_zones_opt}")
1760 fi
1761
1762 echo -n "First sequential zone starts at sector $first_sequential_zone_sector;"
1763 echo " zone size: $((zone_size >> 20)) MB"
1764
1765 zone_cap_bs=$(zone_cap_bs "$dev" "$zone_size")
1766
1767 if [ "${#tests[@]}" = 0 ]; then
1768     readarray -t tests < <(declare -F | grep "test[0-9]*" | \
1769                                    tr -c -d "[:digit:]\n" | sort -n)
1770 fi
1771
1772 logfile=$0.log
1773
1774 passed=0
1775 skipped=0
1776 failed=0
1777 if [ -t 1 ]; then
1778     red="\e[1;31m"
1779     green="\e[1;32m"
1780     cyan="\e[1;36m"
1781     end="\e[m"
1782 else
1783     red=""
1784     green=""
1785     end=""
1786 fi
1787 rc=0
1788
1789 intr=0
1790 trap 'intr=1' SIGINT
1791 ret=0
1792
1793 for test_number in "${tests[@]}"; do
1794     [ "${test_number}" -lt "${start_test}" ] && continue
1795     rm -f "${logfile}.${test_number}"
1796     unset SKIP_REASON
1797     echo -n "Running test $(printf "%02d" $test_number) ... "
1798     eval "test$test_number"
1799     ret=$?
1800     if ((!ret)) && check_log $test_number; then
1801         status="PASS"
1802         cc_status="${green}${status}${end}"
1803         ((passed++))
1804     elif ((ret==SKIP_TESTCASE)); then
1805         status="SKIP"
1806         echo "${SKIP_REASON}" >> "${logfile}.${test_number}"
1807         cc_status="${cyan}${status}${end}    ${SKIP_REASON}"
1808         ((skipped++))
1809     else
1810         status="FAIL"
1811         cc_status="${red}${status}${end}"
1812         ((failed++))
1813         rc=1
1814     fi
1815     echo -e "$cc_status"
1816     echo "$status" >> "${logfile}.${test_number}"
1817     [ $intr -ne 0 ] && exit 1
1818     [ -n "$quit_on_err" -a "$rc" -ne 0 ] && exit 1
1819 done
1820
1821 echo "$passed tests passed"
1822 if [ $skipped -gt 0 ]; then
1823     echo " $skipped tests skipped"
1824 fi
1825 if [ $failed -gt 0 ]; then
1826     echo " $failed tests failed"
1827 fi
1828 echo "Run time: $(TZ=UTC0 printf "%(%H:%M:%S)T\n" $(( SECONDS )) )"
1829 exit $rc