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