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") [-d] [-e] [-l] [-r] [-v] [-t <test>] [-z] <SMR drive device node>"
   9 }
  10
  11 max() {
  12     if [ "$1" -gt "$2" ]; then
  13         echo "$1"
  14     else
  15         echo "$2"
  16     fi
  17 }
  18
  19 min() {
  20     if [ "$1" -lt "$2" ]; then
  21         echo "$1"
  22     else
  23         echo "$2"
  24     fi
  25 }
  26
  27 ioengine() {
  28         if [ -n "$use_libzbc" ]; then
  29                 echo -n "--ioengine=libzbc"
  30         else
  31                 echo -n "--ioengine=$1"
  32         fi
  33 }
  34
  35 set_io_scheduler() {
  36     local dev=$1 sched=$2
  37
  38     [ -e "/sys/block/$dev" ] || return $?
  39     if [ -e "/sys/block/$dev/mq" ]; then
  40         case "$sched" in
  41             noop)        sched=none;;
  42             deadline)    sched=mq-deadline;;
  43         esac
  44     else
  45         case "$sched" in
  46             none)        sched=noop;;
  47             mq-deadline) sched=deadline;;
  48         esac
  49     fi
  50
  51     echo "$sched" >"/sys/block/$dev/queue/scheduler"
  52 }
  53
  54 check_read() {
  55     local read
  56
  57     read=$(fio_read <"${logfile}.${test_number}")
  58     echo "read: $read <> $1" >> "${logfile}.${test_number}"
  59     [ "$read" = "$1" ]
  60 }
  61
  62 check_written() {
  63     local written
  64
  65     written=$(fio_written <"${logfile}.${test_number}")
  66     echo "written: $written <> $1" >> "${logfile}.${test_number}"
  67     [ "$written" = "$1" ]
  68 }
  69
  70 # Compare the reset count from the log file with reset count $2 using operator
  71 # $1 (=, -ge, -gt, -le, -lt).
  72 check_reset_count() {
  73     local reset_count
  74
  75     reset_count=$(fio_reset_count <"${logfile}.${test_number}")
  76     echo "reset_count: test $reset_count $1 $2" >> "${logfile}.${test_number}"
  77     eval "[ '$reset_count' '$1' '$2' ]"
  78 }
  79
  80 # Whether or not $1 (/dev/...) is a SCSI device.
  81 is_scsi_device() {
  82     local d f
  83
  84     d=$(basename "$dev")
  85     for f in /sys/class/scsi_device/*/device/block/"$d"; do
  86         [ -e "$f" ] && return 0
  87     done
  88     return 1
  89 }
  90
  91 run_fio() {
  92     local fio opts
  93
  94     fio=$(dirname "$0")/../../fio
  95
  96     opts=("--max-jobs=16" "--aux-path=/tmp" "--allow_file_create=0" \
  97           "--significant_figures=10" "$@")
  98     opts+=(${var_opts[@]})
  99     { echo; echo "fio ${opts[*]}"; echo; } >>"${logfile}.${test_number}"
 100
 101     "${dynamic_analyzer[@]}" "$fio" "${opts[@]}"
 102 }
 103
 104 run_one_fio_job() {
 105     local r
 106
 107     r=$(((RANDOM << 16) | RANDOM))
 108     run_fio --name="$dev" --filename="$dev" "$@" --randseed="$r"        \
 109             --thread=1 --direct=1
 110 }
 111
 112 # Run fio on the first four sequential zones of the disk.
 113 run_fio_on_seq() {
 114     local opts=()
 115
 116     opts+=("--offset=$((first_sequential_zone_sector * 512))")
 117     opts+=("--size=$((4 * zone_size))" "--zonemode=zbd")
 118     if [ -z "$is_zbd" ]; then
 119         opts+=("--zonesize=${zone_size}")
 120     fi
 121     run_one_fio_job "${opts[@]}" "$@"
 122 }
 123
 124 # Check whether buffered writes are refused.
 125 test1() {
 126     run_fio --name=job1 --filename="$dev" --rw=write --direct=0 --bs=4K \
 127             "$(ioengine "psync")" --size="${zone_size}" --thread=1      \
 128             --zonemode=zbd --zonesize="${zone_size}" 2>&1 |
 129         tee -a "${logfile}.${test_number}" |
 130         grep -q 'Using direct I/O is mandatory for writing to ZBD drives'
 131     local fio_rc=${PIPESTATUS[0]} grep_rc=${PIPESTATUS[2]}
 132     case "$fio_rc" in
 133         0|1) ;;
 134         *)   return "$fio_rc"
 135     esac
 136     if [ -n "$is_zbd" ]; then
 137         [ "$grep_rc" = 0 ]
 138     else
 139         [ "$grep_rc" != 0 ]
 140     fi
 141 }
 142
 143 # Block size exceeds zone size.
 144 test2() {
 145     local bs off opts=() rc
 146
 147     off=$(((first_sequential_zone_sector + 2 * sectors_per_zone) * 512))
 148     bs=$((2 * zone_size))
 149     opts+=("$(ioengine "psync")")
 150     opts+=("--name=job1" "--filename=$dev" "--rw=write" "--direct=1")
 151     opts+=("--zonemode=zbd" "--offset=$off" "--bs=$bs" "--size=$bs")
 152     if [ -z "$is_zbd" ]; then
 153         opts+=("--zonesize=${zone_size}")
 154     fi
 155     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 156     ! grep -q 'WRITE:' "${logfile}.${test_number}"
 157 }
 158
 159 # Run fio against an empty zone. This causes fio to report "No I/O performed".
 160 test3() {
 161     local off opts=() rc
 162
 163     off=$((first_sequential_zone_sector * 512 + 128 * zone_size))
 164     size=$((zone_size))
 165     [ -n "$is_zbd" ] && reset_zone "$dev" $((off / 512))
 166     opts+=("--name=$dev" "--filename=$dev" "--offset=$off" "--bs=4K")
 167     opts+=("--size=$size" "--zonemode=zbd")
 168     opts+=("$(ioengine "psync")" "--rw=read" "--direct=1" "--thread=1")
 169     if [ -z "$is_zbd" ]; then
 170         opts+=("--zonesize=${zone_size}")
 171     fi
 172     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 173     ! grep -q 'READ:' "${logfile}.${test_number}"
 174 }
 175
 176 # Run fio with --read_beyond_wp=1 against an empty zone.
 177 test4() {
 178     local off opts=()
 179
 180     off=$((first_sequential_zone_sector * 512 + 129 * zone_size))
 181     size=$((zone_size))
 182     [ -n "$is_zbd" ] && reset_zone "$dev" $((off / 512))
 183     opts+=("--name=$dev" "--filename=$dev" "--offset=$off" "--bs=$size")
 184     opts+=("--size=$size" "--thread=1" "--read_beyond_wp=1")
 185     opts+=("$(ioengine "psync")" "--rw=read" "--direct=1" "--disable_lat=1")
 186     opts+=("--zonemode=zbd" "--zonesize=${zone_size}")
 187     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 188     check_read $size || return $?
 189 }
 190
 191 # Sequential write to sequential zones.
 192 test5() {
 193     local size
 194
 195     size=$((4 * zone_size))
 196     run_fio_on_seq "$(ioengine "psync")" --iodepth=1 --rw=write \
 197                    --bs="$(max $((zone_size / 64)) "$logical_block_size")"\
 198                    --do_verify=1 --verify=md5                           \
 199                    >>"${logfile}.${test_number}" 2>&1 || return $?
 200     check_written $size || return $?
 201     check_read $size || return $?
 202 }
 203
 204 # Sequential read from sequential zones. Must be run after test5.
 205 test6() {
 206     local size
 207
 208     size=$((4 * zone_size))
 209     run_fio_on_seq "$(ioengine "psync")" --iodepth=1 --rw=read  \
 210                    --bs="$(max $((zone_size / 64)) "$logical_block_size")"\
 211                    >>"${logfile}.${test_number}" 2>&1 || return $?
 212     check_read $size || return $?
 213 }
 214
 215 # Random write to sequential zones, libaio, queue depth 1.
 216 test7() {
 217     local size=$((zone_size))
 218
 219     run_fio_on_seq "$(ioengine "libaio")" --iodepth=1 --rw=randwrite    \
 220                    --bs="$(min 16384 "${zone_size}")"                   \
 221                    --do_verify=1 --verify=md5 --size="$size"            \
 222                    >>"${logfile}.${test_number}" 2>&1 || return $?
 223     check_written $size || return $?
 224     check_read $size || return $?
 225 }
 226
 227 # Random write to sequential zones, libaio, queue depth 64.
 228 test8() {
 229     local size
 230
 231     size=$((4 * zone_size))
 232     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite   \
 233                    --bs="$(min 16384 "${zone_size}")"                   \
 234                    --do_verify=1 --verify=md5                           \
 235                    >>"${logfile}.${test_number}" 2>&1 || return $?
 236     check_written $size || return $?
 237     check_read $size || return $?
 238 }
 239
 240 # Random write to sequential zones, sg, queue depth 1.
 241 test9() {
 242     local size
 243
 244     if ! is_scsi_device "$dev"; then
 245         echo "$dev is not a SCSI device" >>"${logfile}.${test_number}"
 246         return 0
 247     fi
 248
 249     size=$((4 * zone_size))
 250     run_fio_on_seq --ioengine=sg                                        \
 251                    --iodepth=1 --rw=randwrite --bs=16K                  \
 252                    --do_verify=1 --verify=md5                           \
 253                    >>"${logfile}.${test_number}" 2>&1 || return $?
 254     check_written $size || return $?
 255     check_read $size || return $?
 256 }
 257
 258 # Random write to sequential zones, sg, queue depth 64.
 259 test10() {
 260     local size
 261
 262     if ! is_scsi_device "$dev"; then
 263         echo "$dev is not a SCSI device" >>"${logfile}.${test_number}"
 264         return 0
 265     fi
 266
 267     size=$((4 * zone_size))
 268     run_fio_on_seq --ioengine=sg                                        \
 269                    --iodepth=64 --rw=randwrite --bs=16K                 \
 270                    --do_verify=1 --verify=md5                           \
 271                    >>"${logfile}.${test_number}" 2>&1 || return $?
 272     check_written $size || return $?
 273     check_read $size || return $?
 274 }
 275
 276 # Random write to sequential zones, libaio, queue depth 64, random block size.
 277 test11() {
 278     local size
 279
 280     size=$((4 * zone_size))
 281     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite   \
 282                    --bsrange=4K-64K --do_verify=1 --verify=md5          \
 283                    --debug=zbd >>"${logfile}.${test_number}" 2>&1 || return $?
 284     check_written $size || return $?
 285     check_read $size || return $?
 286 }
 287
 288 # Random write to sequential zones, libaio, queue depth 64, max 1 open zone.
 289 test12() {
 290     local size
 291
 292     size=$((8 * zone_size))
 293     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite --bs=16K \
 294                    --max_open_zones=1 --size=$size --do_verify=1 --verify=md5 \
 295                    --debug=zbd >>"${logfile}.${test_number}" 2>&1 || return $?
 296     check_written $size || return $?
 297     check_read $size || return $?
 298 }
 299
 300 # Random write to sequential zones, libaio, queue depth 64, max 4 open zones.
 301 test13() {
 302     local size
 303
 304     size=$((8 * zone_size))
 305     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite --bs=16K \
 306                    --max_open_zones=4 --size=$size --do_verify=1 --verify=md5 \
 307                    --debug=zbd                                                \
 308                    >>"${logfile}.${test_number}" 2>&1 || return $?
 309     check_written $size || return $?
 310     check_read $size || return $?
 311 }
 312
 313 # Random write to conventional zones.
 314 test14() {
 315     local size
 316
 317     size=$((16 * 2**20)) # 20 MB
 318     if [ $size -gt $((first_sequential_zone_sector * 512)) ]; then
 319         echo "$dev does not have enough sequential zones" \
 320              >>"${logfile}.${test_number}"
 321         return 0
 322     fi
 323     run_one_fio_job "$(ioengine "libaio")" --iodepth=64 --rw=randwrite --bs=16K \
 324                     --zonemode=zbd --zonesize="${zone_size}" --do_verify=1 \
 325                     --verify=md5 --size=$size                              \
 326                     >>"${logfile}.${test_number}" 2>&1 || return $?
 327     check_written $((size)) || return $?
 328     check_read $((size)) || return $?
 329 }
 330
 331 # Sequential read on a mix of empty and full zones.
 332 test15() {
 333     local i off size
 334
 335     for ((i=0;i<4;i++)); do
 336         [ -n "$is_zbd" ] &&
 337             reset_zone "$dev" $((first_sequential_zone_sector +
 338                                  i*sectors_per_zone))
 339     done
 340     off=$(((first_sequential_zone_sector + 2 * sectors_per_zone) * 512))
 341     size=$((2 * zone_size))
 342     run_one_fio_job "$(ioengine "psync")" --rw=write --bs=$((zone_size / 16))\
 343                     --zonemode=zbd --zonesize="${zone_size}" --offset=$off \
 344                     --size=$size >>"${logfile}.${test_number}" 2>&1 ||
 345         return $?
 346     check_written $size || return $?
 347     off=$((first_sequential_zone_sector * 512))
 348     size=$((4 * zone_size))
 349     run_one_fio_job "$(ioengine "psync")" --rw=read --bs=$((zone_size / 16)) \
 350                     --zonemode=zbd --zonesize="${zone_size}" --offset=$off \
 351                     --size=$((size)) >>"${logfile}.${test_number}" 2>&1 ||
 352         return $?
 353     if [ -n "$is_zbd" ]; then
 354         check_read $((size / 2))
 355     else
 356         check_read $size
 357     fi
 358 }
 359
 360 # Random read on a mix of empty and full zones. Must be run after test15.
 361 test16() {
 362     local off size
 363
 364     off=$((first_sequential_zone_sector * 512))
 365     size=$((4 * zone_size))
 366     run_one_fio_job "$(ioengine "libaio")" --iodepth=64 --rw=randread --bs=16K \
 367                     --zonemode=zbd --zonesize="${zone_size}" --offset=$off \
 368                     --size=$size >>"${logfile}.${test_number}" 2>&1 || return $?
 369     check_read $size || return $?
 370 }
 371
 372 # Random reads and writes in the last zone.
 373 test17() {
 374     local io off read size written
 375
 376     off=$(((disk_size / zone_size - 1) * zone_size))
 377     size=$((disk_size - off))
 378     # Overwrite the last zone to avoid that reading from that zone fails.
 379     if [ -n "$is_zbd" ]; then
 380         reset_zone "$dev" $((off / 512)) || return $?
 381     fi
 382     run_one_fio_job "$(ioengine "psync")" --rw=write --offset="$off"    \
 383                     --zonemode=zbd --zonesize="${zone_size}"            \
 384                     --bs="$zone_size" --size="$zone_size"               \
 385                     >>"${logfile}.${test_number}" 2>&1 || return $?
 386     check_written "$zone_size" || return $?
 387     run_one_fio_job "$(ioengine "libaio")" --iodepth=8 --rw=randrw --bs=4K \
 388                     --zonemode=zbd --zonesize="${zone_size}"            \
 389                     --offset=$off --loops=2 --norandommap=1\
 390                     >>"${logfile}.${test_number}" 2>&1 || return $?
 391     written=$(fio_written <"${logfile}.${test_number}")
 392     read=$(fio_read <"${logfile}.${test_number}")
 393     io=$((written + read))
 394     echo "Total number of bytes read and written: $io <> $size" \
 395          >>"${logfile}.${test_number}"
 396     [ $io = $((size * 2)) ];
 397 }
 398
 399 # Out-of-range zone reset threshold and frequency parameters.
 400 test18() {
 401     run_fio_on_seq --zone_reset_threshold=-1 |&
 402         tee -a "${logfile}.${test_number}"   |
 403             grep -q 'value out of range' || return $?
 404 }
 405
 406 test19() {
 407     run_fio_on_seq --zone_reset_threshold=2  |&
 408         tee -a "${logfile}.${test_number}"   |
 409         grep -q 'value out of range' || return $?
 410 }
 411
 412 test20() {
 413     run_fio_on_seq --zone_reset_threshold=.4:.6 |&
 414         tee -a "${logfile}.${test_number}"   |
 415         grep -q 'the list exceeding max length' || return $?
 416 }
 417
 418 test21() {
 419     run_fio_on_seq --zone_reset_frequency=-1 |&
 420         tee -a "${logfile}.${test_number}"   |
 421         grep -q 'value out of range' || return $?
 422 }
 423
 424 test22() {
 425     run_fio_on_seq --zone_reset_frequency=2  |&
 426         tee -a "${logfile}.${test_number}"   |
 427         grep -q 'value out of range' || return $?
 428 }
 429
 430 test23() {
 431     run_fio_on_seq --zone_reset_frequency=.4:.6  |&
 432         tee -a "${logfile}.${test_number}"   |
 433         grep -q 'the list exceeding max length' || return $?
 434 }
 435
 436 test24() {
 437     local bs loops=9 size=$((zone_size))
 438
 439     bs=$(min $((256*1024)) "$zone_size")
 440     run_fio_on_seq "$(ioengine "psync")" --rw=write --bs="$bs"          \
 441                    --size=$size --loops=$loops                          \
 442                    --zone_reset_frequency=.01 --zone_reset_threshold=.90 \
 443                    >> "${logfile}.${test_number}" 2>&1 || return $?
 444     check_written $((size * loops)) || return $?
 445     check_reset_count -eq 8 ||
 446         check_reset_count -eq 9 ||
 447         check_reset_count -eq 10 || return $?
 448 }
 449
 450 # Multiple non-overlapping sequential write jobs for the same drive.
 451 test25() {
 452     local i opts=()
 453
 454     for ((i=0;i<16;i++)); do
 455         [ -n "$is_zbd" ] &&
 456             reset_zone "$dev" $((first_sequential_zone_sector + i*sectors_per_zone))
 457     done
 458     for ((i=0;i<16;i++)); do
 459         opts+=("--name=job$i" "--filename=$dev" "--thread=1" "--direct=1")
 460         opts+=("--offset=$((first_sequential_zone_sector*512 + zone_size*i))")
 461         opts+=("--size=$zone_size" "$(ioengine "psync")" "--rw=write" "--bs=16K")
 462         opts+=("--zonemode=zbd" "--zonesize=${zone_size}" "--group_reporting=1")
 463         opts+=(${var_opts[@]})
 464     done
 465     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 466 }
 467
 468 write_to_first_seq_zone() {
 469     local loops=4 r
 470
 471     r=$(((RANDOM << 16) | RANDOM))
 472     run_fio --name="$dev" --filename="$dev" "$(ioengine "psync")" --rw="$1" \
 473             --thread=1 --do_verify=1 --verify=md5 --direct=1 --bs=4K    \
 474             --offset=$((first_sequential_zone_sector * 512))            \
 475             "--size=$zone_size" --loops=$loops --randseed="$r"          \
 476             --zonemode=zbd --zonesize="${zone_size}" --group_reporting=1        \
 477             --gtod_reduce=1 >> "${logfile}.${test_number}" 2>&1 || return $?
 478     check_written $((loops * zone_size)) || return $?
 479 }
 480
 481 # Overwrite the first sequential zone four times sequentially.
 482 test26() {
 483     write_to_first_seq_zone write
 484 }
 485
 486 # Overwrite the first sequential zone four times using random writes.
 487 test27() {
 488     write_to_first_seq_zone randwrite
 489 }
 490
 491 # Multiple overlapping random write jobs for the same drive.
 492 test28() {
 493     local i jobs=16 off opts
 494
 495     off=$((first_sequential_zone_sector * 512 + 64 * zone_size))
 496     [ -n "$is_zbd" ] && reset_zone "$dev" $((off / 512))
 497     opts=("--debug=zbd")
 498     for ((i=0;i<jobs;i++)); do
 499         opts+=("--name=job$i" "--filename=$dev" "--offset=$off" "--bs=16K")
 500         opts+=("--size=$zone_size" "$(ioengine "psync")" "--rw=randwrite")
 501         opts+=("--thread=1" "--direct=1" "--zonemode=zbd")
 502         opts+=("--zonesize=${zone_size}" "--group_reporting=1")
 503         opts+=(${var_opts[@]})
 504     done
 505     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 506     check_written $((jobs * zone_size)) || return $?
 507     check_reset_count -eq $jobs ||
 508         check_reset_count -eq $((jobs - 1)) ||
 509         return $?
 510 }
 511
 512 # Multiple overlapping random write jobs for the same drive and with a limited
 513 # number of open zones.
 514 test29() {
 515     local i jobs=16 off opts=()
 516
 517     off=$((first_sequential_zone_sector * 512 + 64 * zone_size))
 518     size=$((16*zone_size))
 519     [ -n "$is_zbd" ] && reset_zone "$dev" $((off / 512))
 520     opts=("--debug=zbd")
 521     for ((i=0;i<jobs;i++)); do
 522         opts+=("--name=job$i" "--filename=$dev" "--offset=$off" "--bs=16K")
 523         opts+=("--size=$size" "--io_size=$zone_size" "--thread=1")
 524         opts+=("$(ioengine "psync")" "--rw=randwrite" "--direct=1")
 525         opts+=("--max_open_zones=4" "--group_reporting=1")
 526         opts+=("--zonemode=zbd" "--zonesize=${zone_size}")
 527         opts+=(${var_opts[@]})
 528     done
 529     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 530     check_written $((jobs * zone_size)) || return $?
 531 }
 532
 533 # Random reads and writes across the entire disk for 30s.
 534 test30() {
 535     local off
 536
 537     off=$((first_sequential_zone_sector * 512))
 538     run_one_fio_job "$(ioengine "libaio")" --iodepth=8 --rw=randrw      \
 539                     --bs="$(max $((zone_size / 128)) "$logical_block_size")"\
 540                     --zonemode=zbd --zonesize="${zone_size}" --offset=$off\
 541                     --loops=2 --time_based --runtime=30s --norandommap=1\
 542                     >>"${logfile}.${test_number}" 2>&1
 543 }
 544
 545 # Random reads across all sequential zones for 30s. This is not only a fio
 546 # test but also allows to verify the performance of a drive.
 547 test31() {
 548     local bs inc nz off opts size
 549
 550     # Start with writing 128 KB to 128 sequential zones.
 551     bs=128K
 552     nz=128
 553     # shellcheck disable=SC2017
 554     inc=$(((disk_size - (first_sequential_zone_sector * 512)) / (nz * zone_size)
 555            * zone_size))
 556     opts=()
 557     for ((off = first_sequential_zone_sector * 512; off < disk_size;
 558           off += inc)); do
 559         opts+=("--name=$dev" "--filename=$dev" "--offset=$off" "--io_size=$bs")
 560         opts+=("--bs=$bs" "--size=$zone_size" "$(ioengine "libaio")")
 561         opts+=("--rw=write" "--direct=1" "--thread=1" "--stats=0")
 562         opts+=("--zonemode=zbd" "--zonesize=${zone_size}")
 563         opts+=(${var_opts[@]})
 564     done
 565     "$(dirname "$0")/../../fio" "${opts[@]}" >> "${logfile}.${test_number}" 2>&1
 566     # Next, run the test.
 567     off=$((first_sequential_zone_sector * 512))
 568     size=$((disk_size - off))
 569     opts=("--name=$dev" "--filename=$dev" "--offset=$off" "--size=$size")
 570     opts+=("--bs=$bs" "$(ioengine "psync")" "--rw=randread" "--direct=1")
 571     opts+=("--thread=1" "--time_based" "--runtime=30" "--zonemode=zbd")
 572     opts+=("--zonesize=${zone_size}")
 573     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 574 }
 575
 576 # Random writes across all sequential zones. This is not only a fio test but
 577 # also allows to verify the performance of a drive.
 578 test32() {
 579     local off opts=() size
 580
 581     off=$((first_sequential_zone_sector * 512))
 582     size=$((disk_size - off))
 583     opts+=("--name=$dev" "--filename=$dev" "--offset=$off" "--size=$size")
 584     opts+=("--bs=128K" "$(ioengine "psync")" "--rw=randwrite" "--direct=1")
 585     opts+=("--thread=1" "--time_based" "--runtime=30")
 586     opts+=("--max_open_zones=$max_open_zones" "--zonemode=zbd")
 587     opts+=("--zonesize=${zone_size}")
 588     run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 589 }
 590
 591 # Write to sequential zones with a block size that is not a divisor of the
 592 # zone size.
 593 test33() {
 594     local bs io_size size
 595
 596     size=$((2 * zone_size))
 597     io_size=$((5 * zone_size))
 598     bs=$((3 * zone_size / 4))
 599     run_fio_on_seq "$(ioengine "psync")" --iodepth=1 --rw=write \
 600                    --size=$size --io_size=$io_size --bs=$bs     \
 601                    >> "${logfile}.${test_number}" 2>&1 || return $?
 602     check_written $(((io_size + bs - 1) / bs * bs)) || return $?
 603 }
 604
 605 # Write to sequential zones with a block size that is not a divisor of the
 606 # zone size and with data verification enabled.
 607 test34() {
 608     local size
 609
 610     size=$((2 * zone_size))
 611     run_fio_on_seq "$(ioengine "psync")" --iodepth=1 --rw=write --size=$size \
 612                    --do_verify=1 --verify=md5 --bs=$((3 * zone_size / 4)) \
 613                    >> "${logfile}.${test_number}" 2>&1 && return 1
 614     grep -q 'not a divisor of' "${logfile}.${test_number}"
 615 }
 616
 617 # Test 1/4 for the I/O boundary rounding code: $size < $zone_size.
 618 test35() {
 619     local bs off io_size size
 620
 621     off=$(((first_sequential_zone_sector + 1) * 512))
 622     size=$((zone_size - 2 * 512))
 623     bs=$((zone_size / 4))
 624     run_one_fio_job --offset=$off --size=$size "$(ioengine "psync")"    \
 625                     --iodepth=1 --rw=write --do_verify=1 --verify=md5   \
 626                     --bs=$bs --zonemode=zbd --zonesize="${zone_size}"   \
 627                     >> "${logfile}.${test_number}" 2>&1 && return 1
 628     grep -q 'io_size must be at least one zone' "${logfile}.${test_number}"
 629 }
 630
 631 # Test 2/4 for the I/O boundary rounding code: $size < $zone_size.
 632 test36() {
 633     local bs off io_size size
 634
 635     off=$(((first_sequential_zone_sector) * 512))
 636     size=$((zone_size - 512))
 637     bs=$((zone_size / 4))
 638     run_one_fio_job --offset=$off --size=$size "$(ioengine "psync")"    \
 639                     --iodepth=1 --rw=write --do_verify=1 --verify=md5   \
 640                     --bs=$bs --zonemode=zbd --zonesize="${zone_size}"   \
 641                     >> "${logfile}.${test_number}" 2>&1 && return 1
 642     grep -q 'io_size must be at least one zone' "${logfile}.${test_number}"
 643 }
 644
 645 # Test 3/4 for the I/O boundary rounding code: $size > $zone_size.
 646 test37() {
 647     local bs off size
 648
 649     if [ "$first_sequential_zone_sector" = 0 ]; then
 650         off=0
 651     else
 652         off=$(((first_sequential_zone_sector - 1) * 512))
 653     fi
 654     size=$((zone_size + 2 * 512))
 655     bs=$((zone_size / 4))
 656     run_one_fio_job --offset=$off --size=$size "$(ioengine "psync")"    \
 657                     --iodepth=1 --rw=write --do_verify=1 --verify=md5   \
 658                     --bs=$bs --zonemode=zbd --zonesize="${zone_size}"   \
 659                     >> "${logfile}.${test_number}" 2>&1
 660     check_written $((zone_size)) || return $?
 661 }
 662
 663 # Test 4/4 for the I/O boundary rounding code: $offset > $disk_size - $zone_size
 664 test38() {
 665     local bs off size
 666
 667     size=$((logical_block_size))
 668     off=$((disk_size - logical_block_size))
 669     bs=$((logical_block_size))
 670     run_one_fio_job --offset=$off --size=$size "$(ioengine "psync")"    \
 671                     --iodepth=1 --rw=write --do_verify=1 --verify=md5   \
 672                     --bs=$bs --zonemode=zbd --zonesize="${zone_size}"   \
 673                     >> "${logfile}.${test_number}" 2>&1 && return 1
 674     grep -q 'io_size must be at least one zone' "${logfile}.${test_number}"
 675 }
 676
 677 # Read one block from a block device.
 678 read_one_block() {
 679     local bs
 680
 681     bs=$((logical_block_size))
 682     run_one_fio_job --rw=read "$(ioengine "psync")" --bs=$bs --size=$bs "$@" 2>&1 |
 683         tee -a "${logfile}.${test_number}"
 684 }
 685
 686 # Check whether fio accepts --zonemode=none for zoned block devices.
 687 test39() {
 688     [ -n "$is_zbd" ] || return 0
 689     read_one_block --zonemode=none >/dev/null || return $?
 690     check_read $((logical_block_size)) || return $?
 691 }
 692
 693 # Check whether fio accepts --zonemode=strided for zoned block devices.
 694 test40() {
 695     local bs
 696
 697     bs=$((logical_block_size))
 698     [ -n "$is_zbd" ] || return 0
 699     read_one_block --zonemode=strided |
 700         grep -q 'fio: --zonesize must be specified when using --zonemode=strided' ||
 701         return $?
 702     read_one_block --zonemode=strided --zonesize=$bs >/dev/null || return $?
 703     check_read $bs || return $?
 704 }
 705
 706 # Check whether fio checks the zone size for zoned block devices.
 707 test41() {
 708     [ -n "$is_zbd" ] || return 0
 709     read_one_block --zonemode=zbd --zonesize=$((2 * zone_size)) |
 710         grep -q 'job parameter zonesize.*does not match disk zone size'
 711 }
 712
 713 # Check whether fio handles --zonesize=0 correctly for regular block devices.
 714 test42() {
 715     [ -n "$is_zbd" ] && return 0
 716     read_one_block --zonemode=zbd --zonesize=0 |
 717         grep -q 'Specifying the zone size is mandatory for regular block devices with --zonemode=zbd'
 718 }
 719
 720 # Check whether fio handles --zonesize=1 correctly for regular block devices.
 721 test43() {
 722     [ -n "$is_zbd" ] && return 0
 723     read_one_block --zonemode=zbd --zonesize=1 |
 724         grep -q 'zone size must be at least 512 bytes for --zonemode=zbd'
 725 }
 726
 727 # Check whether fio handles --zonemode=none --zonesize=1 correctly.
 728 test44() {
 729     read_one_block --zonemode=none --zonesize=1 |
 730         grep -q 'fio: --zonemode=none and --zonesize are not compatible'
 731 }
 732
 733 test45() {
 734     local bs i
 735
 736     [ -z "$is_zbd" ] && return 0
 737     bs=$((logical_block_size))
 738     run_one_fio_job "$(ioengine "psync")" --iodepth=1 --rw=randwrite --bs=$bs\
 739                     --offset=$((first_sequential_zone_sector * 512)) \
 740                     --size="$zone_size" --do_verify=1 --verify=md5 2>&1 |
 741         tee -a "${logfile}.${test_number}" |
 742         grep -q "fio: first I/O failed. If .* is a zoned block device, consider --zonemode=zbd"
 743 }
 744
 745 # Random write to sequential zones, libaio, 8 jobs, queue depth 64 per job
 746 test46() {
 747     local size
 748
 749     size=$((4 * zone_size))
 750     run_fio_on_seq "$(ioengine "libaio")" --iodepth=64 --rw=randwrite --bs=4K \
 751                    --group_reporting=1 --numjobs=8 \
 752                    >> "${logfile}.${test_number}" 2>&1 || return $?
 753     check_written $((size * 8)) || return $?
 754 }
 755
 756 # Check whether fio handles --zonemode=zbd --zoneskip=1 correctly.
 757 test47() {
 758     local bs
 759
 760     [ -z "$is_zbd" ] && return 0
 761     bs=$((logical_block_size))
 762     run_one_fio_job "$(ioengine "psync")" --rw=write --bs=$bs \
 763                     --zonemode=zbd --zoneskip=1          \
 764                     >> "${logfile}.${test_number}" 2>&1 && return 1
 765     grep -q 'zoneskip 1 is not a multiple of the device zone size' "${logfile}.${test_number}"
 766 }
 767
 768 # Multiple overlapping random write jobs for the same drive and with a
 769 # limited number of open zones. This is similar to test29, but uses libaio
 770 # to stress test zone locking.
 771 test48() {
 772     local i jobs=16 off opts=()
 773
 774     off=$((first_sequential_zone_sector * 512 + 64 * zone_size))
 775     size=$((16*zone_size))
 776     [ -n "$is_zbd" ] && reset_zone "$dev" $((off / 512))
 777     opts=("--aux-path=/tmp" "--allow_file_create=0" "--significant_figures=10")
 778     opts+=("--debug=zbd")
 779     opts+=("$(ioengine "libaio")" "--rw=randwrite" "--direct=1")
 780     opts+=("--time_based" "--runtime=30")
 781     opts+=("--zonemode=zbd" "--zonesize=${zone_size}")
 782     opts+=("--max_open_zones=4")
 783     for ((i=0;i<jobs;i++)); do
 784         opts+=("--name=job$i" "--filename=$dev" "--offset=$off" "--bs=16K")
 785         opts+=("--io_size=$zone_size" "--iodepth=256" "--thread=1")
 786         opts+=("--group_reporting=1")
 787     done
 788
 789     fio=$(dirname "$0")/../../fio
 790
 791     { echo; echo "fio ${opts[*]}"; echo; } >>"${logfile}.${test_number}"
 792
 793     timeout -v -s KILL 45s \
 794             "${dynamic_analyzer[@]}" "$fio" "${opts[@]}" \
 795             >> "${logfile}.${test_number}" 2>&1 || return $?
 796 }
 797
 798 tests=()
 799 dynamic_analyzer=()
 800 reset_all_zones=
 801 use_libzbc=
 802 zbd_debug=
 803
 804 while [ "${1#-}" != "$1" ]; do
 805   case "$1" in
 806     -d) dynamic_analyzer=(valgrind "--read-var-info=yes" "--tool=drd"
 807                           "--show-confl-seg=no");
 808         shift;;
 809     -e) dynamic_analyzer=(valgrind "--read-var-info=yes" "--tool=helgrind");
 810         shift;;
 811     -l) use_libzbc=1; shift;;
 812     -r) reset_all_zones=1; shift;;
 813     -t) tests+=("$2"); shift; shift;;
 814     -v) dynamic_analyzer=(valgrind "--read-var-info=yes");
 815         shift;;
 816     -z) zbd_debug=1; shift;;
 817     --) shift; break;;
 818   esac
 819 done
 820
 821 if [ $# != 1 ]; then
 822     usage
 823     exit 1
 824 fi
 825
 826 # shellcheck source=functions
 827 source "$(dirname "$0")/functions" || exit $?
 828
 829 var_opts=()
 830 if [ -n "$zbd_debug" ]; then
 831     var_opts+=("--debug=zbd")
 832 fi
 833 dev=$1
 834 realdev=$(readlink -f "$dev")
 835 basename=$(basename "$realdev")
 836
 837 if [[ -b "$realdev" ]]; then
 838         major=$((0x$(stat -L -c '%t' "$realdev"))) || exit $?
 839         minor=$((0x$(stat -L -c '%T' "$realdev"))) || exit $?
 840         disk_size=$(($(<"/sys/dev/block/$major:$minor/size")*512))
 841
 842         # When the target is a partition device, get basename of its
 843         # holder device to access sysfs path of the holder device
 844         if [[ -r "/sys/dev/block/$major:$minor/partition" ]]; then
 845                 realsysfs=$(readlink "/sys/dev/block/$major:$minor")
 846                 basename=$(basename "${realsysfs%/*}")
 847         fi
 848         logical_block_size=$(<"/sys/block/$basename/queue/logical_block_size")
 849         case "$(<"/sys/class/block/$basename/queue/zoned")" in
 850         host-managed|host-aware)
 851                 is_zbd=true
 852                 if ! result=($(first_sequential_zone "$dev")); then
 853                         echo "Failed to determine first sequential zone"
 854                         exit 1
 855                 fi
 856                 first_sequential_zone_sector=${result[0]}
 857                 sectors_per_zone=${result[1]}
 858                 zone_size=$((sectors_per_zone * 512))
 859                 if ! max_open_zones=$(max_open_zones "$dev"); then
 860                         echo "Failed to determine maximum number of open zones"
 861                         exit 1
 862                 fi
 863                 set_io_scheduler "$basename" deadline || exit $?
 864                 if [ -n "$reset_all_zones" ]; then
 865                         reset_zone "$dev" -1
 866                 fi
 867                 ;;
 868         *)
 869                 first_sequential_zone_sector=$(((disk_size / 2) &
 870                                                 (logical_block_size - 1)))
 871                 zone_size=$(max 65536 "$logical_block_size")
 872                 sectors_per_zone=$((zone_size / 512))
 873                 max_open_zones=128
 874                 set_io_scheduler "$basename" none || exit $?
 875                 ;;
 876         esac
 877 elif [[ -c "$realdev" ]]; then
 878         # For an SG node, we must have libzbc option specified
 879         if [[ ! -n "$use_libzbc" ]]; then
 880                 echo "Character device files can only be used with -l (libzbc) option"
 881                 exit 1
 882         fi
 883
 884         if ! $(is_zbc "$dev"); then
 885                 echo "Device is not a ZBC disk"
 886                 exit 1
 887         fi
 888         is_zbd=true
 889
 890         if ! disk_size=($(( $(zbc_disk_sectors "$dev") * 512))); then
 891                 echo "Failed to determine disk size"
 892                 exit 1
 893         fi
 894         if ! logical_block_size=($(zbc_logical_block_size "$dev")); then
 895                 echo "Failed to determine logical block size"
 896                 exit 1
 897         fi
 898         if ! result=($(first_sequential_zone "$dev")); then
 899                 echo "Failed to determine first sequential zone"
 900                 exit 1
 901         fi
 902         first_sequential_zone_sector=${result[0]}
 903         sectors_per_zone=${result[1]}
 904         zone_size=$((sectors_per_zone * 512))
 905         if ! max_open_zones=$(max_open_zones "$dev"); then
 906                 echo "Failed to determine maximum number of open zones"
 907                 exit 1
 908         fi
 909         if [ -n "$reset_all_zones" ]; then
 910                 reset_zone "$dev" -1
 911         fi
 912 fi
 913
 914 echo -n "First sequential zone starts at sector $first_sequential_zone_sector;"
 915 echo " zone size: $((zone_size >> 20)) MB"
 916
 917 if [ "${#tests[@]}" = 0 ]; then
 918     readarray -t tests < <(declare -F | grep "test[0-9]*" | \
 919                                    tr -c -d "[:digit:]\n" | sort -n)
 920 fi
 921
 922 logfile=$0.log
 923
 924 passed=0
 925 failed=0
 926 if [ -t 1 ]; then
 927     red="\e[1;31m"
 928     green="\e[1;32m"
 929     end="\e[m"
 930 else
 931     red=""
 932     green=""
 933     end=""
 934 fi
 935 rc=0
 936
 937 intr=0
 938 trap 'intr=1' SIGINT
 939
 940 for test_number in "${tests[@]}"; do
 941     rm -f "${logfile}.${test_number}"
 942     echo -n "Running test $(printf "%02d" $test_number) ... "
 943     if eval "test$test_number"; then
 944         status="PASS"
 945         cc_status="${green}${status}${end}"
 946         ((passed++))
 947     else
 948         status="FAIL"
 949         cc_status="${red}${status}${end}"
 950         ((failed++))
 951         rc=1
 952     fi
 953     echo -e "$cc_status"
 954     echo "$status" >> "${logfile}.${test_number}"
 955     [ $intr -ne 0 ] && exit 1
 956 done
 957
 958 echo "$passed tests passed"
 959 if [ $failed -gt 0 ]; then
 960     echo " and $failed tests failed"
 961 fi
 962 exit $rc