3 blkzone=$(type -p blkzone 2>/dev/null)
4 sg_inq=$(type -p sg_inq 2>/dev/null)
5 zbc_report_zones=$(type -p zbc_report_zones 2>/dev/null)
6 zbc_reset_zone=$(type -p zbc_reset_zone 2>/dev/null)
7 zbc_close_zone=$(type -p zbc_close_zone 2>/dev/null)
8 zbc_info=$(type -p zbc_info 2>/dev/null)
9 if [ -z "${blkzone}" ] &&
10 { [ -z "${zbc_report_zones}" ] || [ -z "${zbc_reset_zone}" ]; }; then
11 echo "Error: neither blkzone nor zbc_report_zones is available"
15 if [ -n "${use_libzbc}" ] &&
16 { [ -z "${zbc_report_zones}" ] || [ -z "${zbc_reset_zone}" ] ||
17 [ -z "${zbc_info}" ]; }; then
18 echo "Error: zbc_report_zones, or zbc_reset_zone or zbc_info is not available"
19 echo "Error: reinstall libzbc tools"
23 blkzone_reports_capacity() {
26 [[ -n "${blkzone}" ]] &&
27 "${blkzone}" report -c 1 -o 0 "${dev}" | grep -q 'cap '
33 cmd_path=$(type -p "${cmd}" 2>/dev/null)
34 if [ -z "${cmd_path}" ]; then
35 echo "${cmd} is not available"
41 # Whether or not $1 (/dev/...) is a NVME ZNS device.
45 s=/sys/block/$(basename "${1}")/device/subsystem
47 if [[ ! -h "${s}" || $(realpath "${s}") != /sys/class/nvme ]]; then
51 [[ $(</sys/block/$(basename "${1}")/queue/zoned) == host-managed ]]
54 # Whether or not $1 (/dev/...) is a null_blk device with zone capacity smaller
56 is_nullb_with_zone_cap() {
59 f=/sys/kernel/config/nullb/$(basename "${1}")
60 [[ -r "${f}/zone_capacity" &&
61 $(<"${f}/zone_capacity") -lt $(<"${f}/zone_size") ]]
64 # Check if blkzone is available and suitable for the test target device. If not
65 # available, print error message and return 1. Otherwise return 0.
69 # If the device supports zone capacity, mandate zone capacity report by
71 if (is_nvme_zns "${dev}" || is_nullb_with_zone_cap "${dev}") &&
72 ! blkzone_reports_capacity "${dev}"; then
73 echo "Error: blkzone does not report zone capacity"
74 echo "Error: install latest util-linux with blkzone"
79 # Check zone capacity of each zone and report block size aligned to the zone
80 # capacities. If zone capacity is same as zone size for zones, report zone size.
83 local zone_size="${2}"
84 local sed_str='s/.*len \([0-9A-Za-z]*\), cap \([0-9A-Za-z]*\).*/\1 \2/p'
85 local cap bs="$zone_size"
87 # When blkzone command is neither available nor relevant to the
88 # test device, or when blkzone command does not report capacity,
89 # assume that zone capacity is same as zone size for all zones.
90 if [ -z "${blkzone}" ] || [ -z "$is_zbd" ] || [ -c "$dev" ] ||
91 ! blkzone_reports_capacity "${dev}"; then
96 while read -r -a line; do
97 ((line[0] == line[1])) && continue
98 cap=$((line[1] * 512))
99 while ((bs > 512 && cap % bs)); do
102 done < <(blkzone report "${dev}" | sed -n "${sed_str}")
107 # Reports the starting sector and length of the first sequential zone of device
109 first_sequential_zone() {
112 if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
113 ${blkzone} report "$dev" |
114 sed -n 's/^[[:blank:]]*start:[[:blank:]]\([0-9a-zA-Z]*\),[[:blank:]]len[[:blank:]]\([0-9a-zA-Z]*\),.*zcond:\(14\|[[:blank:]][0-4]\)(.*type:[[:blank:]]\([2]\)(.*/\1 \2/p' |
116 read -r starting_sector length &&
117 # Convert from hex to decimal
118 echo $((starting_sector)) $((length))
121 ${zbc_report_zones} "$dev" |
122 sed -n 's/^Zone [0-9]*: type 0x2 .*,[[:blank:]]cond[[:blank:]]0x[0-4e][[:blank:]].*, sector \([0-9]*\), \([0-9]*\) sectors.*$/\1 \2/p' |
127 # Reports the summed zone capacity of $1 number of zones starting from offset $2
129 total_zone_capacity() {
131 local sector=$(($2 / 512))
136 if [ -z "$is_zbd" ]; then
137 # For regular block devices, handle zone size as zone capacity.
138 echo $((zone_size * nr_zones))
142 if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
143 if blkzone_reports_capacity "${dev}"; then
144 grep_str='cap \K[0-9a-zA-Z]*'
146 # If zone capacity is not reported, refer zone length.
147 grep_str='len \K[0-9a-zA-Z]*'
150 capacity=$((capacity + num))
151 done < <(${blkzone} report -c "$nr_zones" -o "$sector" "$dev" |
152 grep -Po "${grep_str}")
154 # ZBC devices do not have zone capacity. Use zone size.
156 capacity=$((capacity + num))
157 done < <(${zbc_report_zones} -nz "$nr_zones" -start "$sector" \
158 "$dev" | grep -Po 'sector [0-9]*, \K[0-9]*')
161 echo $((capacity * 512))
164 # Reports the starting sector and length of the first zone of device $1
165 # that is not in offline (or similar) condition.
166 first_online_zone() {
169 if [ -z "$is_zbd" ]; then
174 if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
175 ${blkzone} report "$dev" |
176 sed -n 's/^[[:blank:]]*start:[[:blank:]]\([0-9a-zA-Z]*\),[[:blank:]]len[[:blank:]]\([0-9a-zA-Z]*\),.*zcond:\(14\|[[:blank:]][0-4]\)(.*type:[[:blank:]][12](.*/\1/p' |
179 read -r starting_sector &&
180 # Convert from hex to decimal
181 echo $((starting_sector))
184 ${zbc_report_zones} "$dev" |
185 sed -n 's/^Zone[[:blank:]][0-9]*:[[:blank:]]type[[:blank:]]0x[12][[:blank:]].*,[[:blank:]]cond[[:blank:]]0x[0-4e][[:blank:]].*,[[:blank:]]sector[[:blank:]]\([0-9]*\),.*$/\1/p' |
190 # Reports the starting sector and length of the last zone of device $1
191 # that is not in offline (or similar) condition.
195 if [ -z "$is_zbd" ]; then
200 if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
201 ${blkzone} report "$dev" |
202 sed -n 's/^[[:blank:]]*start:[[:blank:]]\([0-9a-zA-Z]*\),[[:blank:]]len[[:blank:]]\([0-9a-zA-Z]*\),.*zcond:\(14\|[[:blank:]][0-4]\)(.*type:[[:blank:]][12](.*/\1/p' |
205 read -r starting_sector &&
206 # Convert from hex to decimal
207 echo $((starting_sector))
210 ${zbc_report_zones} "$dev" |
211 sed -n 's/^Zone[[:blank:]][0-9]*:[[:blank:]]type[[:blank:]]0x[12][[:blank:]].*,[[:blank:]]cond[[:blank:]]0x[0-4e][[:blank:]].*,[[:blank:]]sector[[:blank:]]\([0-9]*\),.*$/\1/p' |
216 # Get max_open_zones of SMR drives using sg_inq or libzbc tools. Two test cases
217 # 31 and 32 use this max_open_zones value. The test case 31 uses max_open_zones
218 # to decide number of write target zones. The test case 32 passes max_open_zones
219 # value to fio with --max_open_zones option. Of note is that fio itself has the
220 # feature to get max_open_zones from the device through sysfs or ioengine
221 # specific implementation. This max_open_zones fetch by test script is required
222 # in case fio is running on an old Linux kernel version which lacks
223 # max_open_zones in sysfs, or which lacks zoned block device support completely.
226 local realdev syspath
228 realdev=$(readlink -f "$dev")
229 syspath=/sys/block/${realdev##*/}/queue/max_open_zones
231 if [ -b "${realdev}" ] && [ -r "${syspath}" ]; then
233 elif [ -n "${sg_inq}" ] && [ ! -n "${use_libzbc}" ]; then
234 if ! ${sg_inq} -e --page=0xB6 --len=20 --hex "$dev" \
235 > /dev/null 2>&1; then
236 # When sg_inq can not get max open zones, specify 0 which indicates
237 # fio to get max open zones limit from the device.
240 ${sg_inq} -e --page=0xB6 --len=20 --hex "$dev" | tail -1 |
242 read -r offset b0 b1 b2 b3 trailer || return $?
243 # Convert from hex to decimal
244 max_nr_open_zones=$((0x${b0}))
245 max_nr_open_zones=$((max_nr_open_zones * 256 + 0x${b1}))
246 max_nr_open_zones=$((max_nr_open_zones * 256 + 0x${b2}))
247 max_nr_open_zones=$((max_nr_open_zones * 256 + 0x${b3}))
248 echo ${max_nr_open_zones}
251 elif [ -n "${use_libzbc}" ]; then
252 ${zbc_report_zones} "$dev" |
253 sed -n 's/^[[:blank:]]*Maximum number of open sequential write required zones:[[:blank:]]*//p'
259 # If sysfs provides, get max_active_zones limit of the zoned block device.
262 local sys_queue="/sys/block/${dev##*/}/queue/"
264 if [[ -e "$sys_queue/max_active_zones" ]]; then
265 cat "$sys_queue/max_active_zones"
271 # Get minimum block size to write to seq zones. Refer the sysfs attribute
272 # zone_write_granularity which shows the valid minimum size regardless of zoned
273 # block device type. If the sysfs attribute is not available, refer physical
274 # block size for rotational SMR drives. For non-rotational devices such as ZNS
275 # devices, refer logical block size.
276 min_seq_write_size() {
277 local sys_path="/sys/block/$1/queue"
280 if [[ -r "$sys_path/zone_write_granularity" ]]; then
281 size=$(<"$sys_path/zone_write_granularity")
286 elif (($(<"$sys_path/rotational"))); then
287 cat "$sys_path/physical_block_size"
289 cat "$sys_path/logical_block_size"
296 if [ -n "${sg_inq}" ] && [ ! -n "${use_libzbc}" ]; then
297 if ! ${sg_inq} -e --page=0xB6 --len=10 --hex "$dev" \
298 > /dev/null 2>&1; then
299 # Couldn't get URSWRZ bit. Assume the reads are unrestricted
300 # because this configuration is more common.
303 ${sg_inq} -e --page=0xB6 --len=10 --hex "$dev" | tail -1 |
305 read -r offset b0 b1 b2 b3 b4 trailer && \
306 echo $(( $b4 & 0x01 )) || echo 0
311 sed -n 's/^[[:blank:]].*Read commands are \(un\)restricted*/\1/p' | grep -q ^ && echo 1 || echo 0
318 [[ -z "$(${zbc_info} "$dev" | grep "is not a zoned block device")" ]]
321 zbc_physical_block_size() {
325 grep "physical blocks" |
326 sed -n 's/^[[:blank:]]*[0-9]* physical blocks of[[:blank:]]*//p' |
334 grep "512-bytes sectors" |
335 sed -e 's/[[:blank:]]*\([0-9]*\)512-bytes sectors.*/\1/'
338 # Reset the write pointer of one zone on device $1 at offset $2. The offset
339 # must be specified in units of 512 byte sectors. Offset -1 means reset all
342 local dev=$1 offset=$2 sectors
344 if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
345 if [ "$offset" -lt 0 ]; then
346 ${blkzone} reset "$dev"
348 ${blkzone} reset -o "${offset}" -c 1 "$dev"
351 if [ "$offset" -lt 0 ]; then
352 ${zbc_reset_zone} -all "$dev" >/dev/null
354 ${zbc_reset_zone} -sector "$dev" "${offset}" >/dev/null
359 # Close the zone on device $1 at offset $2. The offset must be specified in
360 # units of 512 byte sectors.
362 local dev=$1 offset=$2
364 if [ -n "${blkzone}" ] && [ -z "${use_libzbc}" ]; then
365 ${blkzone} close -o "${offset}" -c 1 "$dev"
367 ${zbc_close_zone} -sector "$dev" "${offset}" >/dev/null
371 # Extract the number of bytes that have been transferred from a line like
372 # READ: bw=6847KiB/s (7011kB/s), 6847KiB/s-6847KiB/s (7011kB/s-7011kB/s), io=257MiB (269MB), run=38406-38406msec
374 sed -n 's/^[[:blank:]]*'"$1"'.*, io=\([^[:blank:]]*\).*/\1/p' |
378 # Parse <number>.<number><suffix> into n1, n2 and s. See also
381 n1=${io%${io##*([0-9])}}
382 s=${io#${io%%*([a-zA-Z])}}
394 [ -n "$n1" ] || return 1
395 echo $(((n1 << m) + (n2 << m) / 1000))
410 count=$(sed -n 's/^.*write:[^;]*; \([0-9]*\) zone resets$/\1/p')