[fio.git] / t / zbd / functions

#!/bin/bash

blkzone=$(type -p blkzone 2>/dev/null)
sg_inq=$(type -p sg_inq 2>/dev/null)
zbc_report_zones=$(type -p zbc_report_zones 2>/dev/null)
zbc_reset_zone=$(type -p zbc_reset_zone 2>/dev/null)
zbc_close_zone=$(type -p zbc_close_zone 2>/dev/null)
zbc_info=$(type -p zbc_info 2>/dev/null)
if [ -z "${blkzone}" ] &&
       { [ -z "${zbc_report_zones}" ] || [ -z "${zbc_reset_zone}" ]; }; then
    echo "Error: neither blkzone nor zbc_report_zones is available"
    exit 1
fi

if [ -n "${use_libzbc}" ] &&
       { [ -z "${zbc_report_zones}" ] || [ -z "${zbc_reset_zone}" ] ||
         [ -z "${zbc_info}" ]; }; then
    echo "Error: zbc_report_zones, or zbc_reset_zone or zbc_info is not available"
    echo "Error: reinstall libzbc tools"
    exit 1
fi

blkzone_reports_capacity() {
	local dev="${1}"

	[[ -n "${blkzone}" ]] &&
		"${blkzone}" report -c 1 -o 0 "${dev}" | grep -q 'cap '
}

has_command() {
	local cmd="${1}"

	cmd_path=$(type -p "${cmd}" 2>/dev/null)
	if [ -z "${cmd_path}" ]; then
		echo "${cmd} is not available"
		return 1
	fi
	return 0
}

# Whether or not $1 (/dev/...) is a NVME ZNS device.
is_nvme_zns() {
	local s

	s=/sys/block/$(basename "${1}")/device/subsystem

	if [[ ! -h "${s}" || $(realpath "${s}") != /sys/class/nvme ]]; then
		return 1
	fi

	[[ $(</sys/block/$(basename "${1}")/queue/zoned) == host-managed ]]
}

# Whether or not $1 (/dev/...) is a null_blk device with zone capacity smaller
# than zone size.
is_nullb_with_zone_cap() {
	local f

	f=/sys/kernel/config/nullb/$(basename "${1}")
	[[ -r "${f}/zone_capacity" &&
		   $(<"${f}/zone_capacity") -lt $(<"${f}/zone_size") ]]
}

# Check if blkzone is available and suitable for the test target device. If not
# available, print error message and return 1. Otherwise return 0.
check_blkzone() {
	local dev="${1}"

	# If the device supports zone capacity, mandate zone capacity report by
	# blkzone.
	if (is_nvme_zns "${dev}" || is_nullb_with_zone_cap "${dev}") &&
				! blkzone_reports_capacity "${dev}"; then
		echo "Error: blkzone does not report zone capacity"
		echo "Error: install latest util-linux with blkzone"
		return 1
	fi
}

# Check zone capacity of each zone and report block size aligned to the zone
# capacities. If zone capacity is same as zone size for zones, report zone size.
zone_cap_bs() {
	local dev="${1}"
	local zone_size="${2}"
	local sed_str='s/.*len \([0-9A-Za-z]*\), cap \([0-9A-Za-z]*\).*/\1 \2/p'
	local cap bs="$zone_size"

	# When blkzone command is neither available nor relevant to the
	# test device, or when blkzone command does not report capacity,
	# assume that zone capacity is same as zone size for all zones.
	if [ -z "${blkzone}" ] || [ -z "$is_zbd" ] || [ -c "$dev" ] ||
		   ! blkzone_reports_capacity "${dev}"; then
		echo "$zone_size"
		return
	fi

	while read -r -a line; do
		((line[0] == line[1])) && continue
		cap=$((line[1] * 512))
		while ((bs > 512 && cap % bs)); do
			bs=$((bs / 2))
		done
	done < <(blkzone report "${dev}" | sed -n "${sed_str}")

	echo "$bs"
}

# Reports the starting sector and length of the first sequential zone of device
# $1.
first_sequential_zone() {
    local dev=$1

    if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
	${blkzone} report "$dev" |
	    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' |
	    {
		read -r starting_sector length &&
		    # Convert from hex to decimal
		    echo $((starting_sector)) $((length))
	    }
    else
	${zbc_report_zones} "$dev" |
	    sed -n 's/^Zone [0-9]*: type 0x2 .*,[[:blank:]]cond[[:blank:]]0x[0-4e][[:blank:]].*, sector \([0-9]*\), \([0-9]*\) sectors.*$/\1 \2/p' |
	    head -n1
    fi
}

# Reports the summed zone capacity of $1 number of zones starting from offset $2
# on device $3.
total_zone_capacity() {
	local nr_zones=$1
	local sector=$(($2 / 512))
	local dev=$3
	local capacity=0 num
	local grep_str

	if [ -z "$is_zbd" ]; then
		# For regular block devices, handle zone size as zone capacity.
		echo $((zone_size * nr_zones))
		return
	fi

	if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
		if blkzone_reports_capacity "${dev}"; then
			grep_str='cap \K[0-9a-zA-Z]*'
		else
			# If zone capacity is not reported, refer zone length.
			grep_str='len \K[0-9a-zA-Z]*'
		fi
		while read num; do
			capacity=$((capacity + num))
		done < <(${blkzone} report -c "$nr_zones" -o "$sector" "$dev" |
				grep -Po "${grep_str}")
	else
		# ZBC devices do not have zone capacity. Use zone size.
		while read num; do
			capacity=$((capacity + num))
		done < <(${zbc_report_zones} -nz "$nr_zones" -start "$sector" \
				"$dev" | grep -Po 'sector [0-9]*, \K[0-9]*')
	fi

	echo $((capacity * 512))
}

# Reports the starting sector and length of the first zone of device $1
# that is not in offline (or similar) condition.
first_online_zone() {
    local dev=$1

    if [ -z "$is_zbd" ]; then
	echo 0
	return
    fi

    if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
	${blkzone} report "$dev" |
	    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' |
	    head -n1 |
	    {
		read -r starting_sector &&
		    # Convert from hex to decimal
		    echo $((starting_sector))
	    }
    else
	${zbc_report_zones} "$dev" |
	    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' |
	    head -n1
    fi
}

# Reports the starting sector and length of the last zone of device $1
# that is not in offline (or similar) condition.
last_online_zone() {
    local dev=$1

    if [ -z "$is_zbd" ]; then
	echo 0
	return
    fi

    if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
	${blkzone} report "$dev" |
	    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' |
	    tail -1 |
	    {
		read -r starting_sector &&
		    # Convert from hex to decimal
		    echo $((starting_sector))
	    }
    else
	${zbc_report_zones} "$dev" |
	    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' |
	    tail -1
    fi
}

# Get max_open_zones of SMR drives using sg_inq or libzbc tools. Two test cases
# 31 and 32 use this max_open_zones value. The test case 31 uses max_open_zones
# to decide number of write target zones. The test case 32 passes max_open_zones
# value to fio with --max_open_zones option. Of note is that fio itself has the
# feature to get max_open_zones from the device through sysfs or ioengine
# specific implementation. This max_open_zones fetch by test script is required
# in case fio is running on an old Linux kernel version which lacks
# max_open_zones in sysfs, or which lacks zoned block device support completely.
max_open_zones() {
    local dev=$1
    local realdev syspath

    realdev=$(readlink -f "$dev")
    syspath=/sys/block/${realdev##*/}/queue/max_open_zones

    if [ -b "${realdev}" ] && [ -r "${syspath}" ]; then
	cat ${syspath}
    elif [ -n "${sg_inq}" ] && [ ! -n "${use_libzbc}" ]; then
	if ! ${sg_inq} -e --page=0xB6 --len=20 --hex "$dev" \
		 > /dev/null 2>&1; then
	    # When sg_inq can not get max open zones, specify 0 which indicates
	    # fio to get max open zones limit from the device.
	    echo 0
	else
	    ${sg_inq} -e --page=0xB6 --len=20 --hex "$dev" | tail -1 |
		{
		    read -r offset b0 b1 b2 b3 trailer || return $?
		    # Convert from hex to decimal
		    max_nr_open_zones=$((0x${b0}))
		    max_nr_open_zones=$((max_nr_open_zones * 256 + 0x${b1}))
		    max_nr_open_zones=$((max_nr_open_zones * 256 + 0x${b2}))
		    max_nr_open_zones=$((max_nr_open_zones * 256 + 0x${b3}))
		    echo ${max_nr_open_zones}
		}
	fi
    elif [ -n "${use_libzbc}" ]; then
	${zbc_report_zones} "$dev" |
	    sed -n 's/^[[:blank:]]*Maximum number of open sequential write required zones:[[:blank:]]*//p'
    else
	echo 0
    fi
}

# If sysfs provides, get max_active_zones limit of the zoned block device.
max_active_zones() {
	local dev=$1
	local sys_queue="/sys/block/${dev##*/}/queue/"

	if [[ -e "$sys_queue/max_active_zones" ]]; then
		cat "$sys_queue/max_active_zones"
		return
	fi
	echo 0
}

# Get minimum block size to write to seq zones. Refer the sysfs attribute
# zone_write_granularity which shows the valid minimum size regardless of zoned
# block device type. If the sysfs attribute is not available, refer physical
# block size for rotational SMR drives. For non-rotational devices such as ZNS
# devices, refer logical block size.
min_seq_write_size() {
	local sys_path="/sys/block/$1/queue"
	local -i size=0

	if [[ -r "$sys_path/zone_write_granularity" ]]; then
		size=$(<"$sys_path/zone_write_granularity")
	fi

	if ((size)); then
		echo "$size"
	elif (($(<"$sys_path/rotational"))); then
		cat "$sys_path/physical_block_size"
	else
		cat "$sys_path/logical_block_size"
	fi
}

urswrz() {
    local dev=$1

    if [ -n "${sg_inq}" ] && [ ! -n "${use_libzbc}" ]; then
	if ! ${sg_inq} -e --page=0xB6 --len=10 --hex "$dev" \
		 > /dev/null 2>&1; then
	    # Couldn't get URSWRZ bit. Assume the reads are unrestricted
	    # because this configuration is more common.
	    echo 1
	else
	    ${sg_inq} -e --page=0xB6 --len=10 --hex "$dev" | tail -1 |
		{
		    read -r offset b0 b1 b2 b3 b4 trailer && \
			echo $(( $b4 & 0x01 )) || echo 0
		}
	fi
    else
	${zbc_info} "$dev" |
	    sed -n 's/^[[:blank:]].*Read commands are \(un\)restricted*/\1/p' | grep -q ^ && echo 1 || echo 0
    fi
}

is_zbc() {
	local dev=$1

	[[ -z "$(${zbc_info} "$dev" | grep "is not a zoned block device")" ]]
}

zbc_physical_block_size() {
	local dev=$1

	${zbc_info} "$dev" |
		grep "physical blocks" |
		sed -n 's/^[[:blank:]]*[0-9]* physical blocks of[[:blank:]]*//p' |
		sed 's/ B//'
}

zbc_disk_sectors() {
        local dev=$1

	zbc_info "$dev" |
		grep "512-bytes sectors" |
		sed -e 's/[[:blank:]]*\([0-9]*\)512-bytes sectors.*/\1/'
}

# Reset the write pointer of one zone on device $1 at offset $2. The offset
# must be specified in units of 512 byte sectors. Offset -1 means reset all
# zones.
reset_zone() {
    local dev=$1 offset=$2 sectors

    if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
	if [ "$offset" -lt 0 ]; then
	    ${blkzone} reset "$dev"
	else
	    ${blkzone} reset -o "${offset}" -c 1 "$dev"
	fi
    else
	if [ "$offset" -lt 0 ]; then
	    ${zbc_reset_zone} -all "$dev" >/dev/null
	else
	    ${zbc_reset_zone} -sector "$dev" "${offset}" >/dev/null
	fi
    fi
}

# Close the zone on device $1 at offset $2. The offset must be specified in
# units of 512 byte sectors.
close_zone() {
	local dev=$1 offset=$2

	if [ -n "${blkzone}" ] && [ -z "${use_libzbc}" ]; then
		${blkzone} close -o "${offset}" -c 1 "$dev"
	else
		${zbc_close_zone} -sector "$dev" "${offset}" >/dev/null
	fi
}

# Extract the number of bytes that have been transferred from a line like
# READ: bw=6847KiB/s (7011kB/s), 6847KiB/s-6847KiB/s (7011kB/s-7011kB/s), io=257MiB (269MB), run=38406-38406msec
fio_io() {
    sed -n 's/^[[:blank:]]*'"$1"'.*, io=\([^[:blank:]]*\).*/\1/p' |
	tail -n 1 |
	(
	    read -r io;
	    # Parse <number>.<number><suffix> into n1, n2 and s. See also
	    # num2str().
	    shopt -s extglob
	    n1=${io%${io##*([0-9])}}
	    s=${io#${io%%*([a-zA-Z])}}
	    n2=${io#${n1}}
	    n2=${n2#.}
	    n2=${n2%$s}000
	    n2=${n2:0:3}
	    case "$s" in
		KiB) m=10;;
		MiB) m=20;;
		GiB) m=30;;
		B)   m=0;;
		*)   return 1;;
	    esac
	    [ -n "$n1" ] || return 1
	    echo $(((n1 << m) + (n2 << m) / 1000))
	)
}

fio_read() {
    fio_io 'READ:'
}

fio_written() {
    fio_io 'WRITE:'
}

fio_reset_count() {
    local count

    count=$(sed -n 's/^.*write:[^;]*; \([0-9]*\) zone resets$/\1/p')
    echo "${count:-0}"
}
Commit	Line	Data
191d1d1a BVA	1	#!/bin/bash
191d1d1a BVA	2
68ecd85e SK	3	blkzone=$(type -p blkzone 2>/dev/null)
68ecd85e SK	4	sg_inq=$(type -p sg_inq 2>/dev/null)
191d1d1a BVA	5	zbc_report_zones=$(type -p zbc_report_zones 2>/dev/null)
191d1d1a BVA	6	zbc_reset_zone=$(type -p zbc_reset_zone 2>/dev/null)
00080a1e	7	zbc_close_zone=$(type -p zbc_close_zone 2>/dev/null)
6dcb098d	8	zbc_info=$(type -p zbc_info 2>/dev/null)
191d1d1a BVA	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"
	12	exit 1
	13	fi
	14
6dcb098d DF	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"
	20	exit 1
	21	fi
	22
552e214c SK	23	blkzone_reports_capacity() {
	24	local dev="${1}"
	25
	26	[[ -n "${blkzone}" ]] &&
	27	"${blkzone}" report -c 1 -o 0 "${dev}" \| grep -q 'cap '
	28	}
	29
996ac91f SK	30	has_command() {
	31	local cmd="${1}"
	32
	33	cmd_path=$(type -p "${cmd}" 2>/dev/null)
	34	if [ -z "${cmd_path}" ]; then
	35	echo "${cmd} is not available"
	36	return 1
	37	fi
	38	return 0
	39	}
	40
552e214c SK	41	# Whether or not $1 (/dev/...) is a NVME ZNS device.
	42	is_nvme_zns() {
	43	local s
	44
	45	s=/sys/block/$(basename "${1}")/device/subsystem
	46
	47	if [[ ! -h "${s}" \|\| $(realpath "${s}") != /sys/class/nvme ]]; then
	48	return 1
	49	fi
	50
	51	[[ $(</sys/block/$(basename "${1}")/queue/zoned) == host-managed ]]
	52	}
	53
	54	# Whether or not $1 (/dev/...) is a null_blk device with zone capacity smaller
	55	# than zone size.
	56	is_nullb_with_zone_cap() {
	57	local f
	58
	59	f=/sys/kernel/config/nullb/$(basename "${1}")
	60	[[ -r "${f}/zone_capacity" &&
	61	$(<"${f}/zone_capacity") -lt $(<"${f}/zone_size") ]]
	62	}
	63
	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.
	66	check_blkzone() {
	67	local dev="${1}"
	68
	69	# If the device supports zone capacity, mandate zone capacity report by
	70	# blkzone.
	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"
	75	return 1
	76	fi
	77	}
	78
1ae82d67 SK	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.
	81	zone_cap_bs() {
	82	local dev="${1}"
	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"
	86
9ffe433d SK	87	# When blkzone command is neither available nor relevant to the
9ffe433d SK	88	# test device, or when blkzone command does not report capacity,
1ae82d67	89	# assume that zone capacity is same as zone size for all zones.
9ffe433d SK	90	if [ -z "${blkzone}" ] \|\| [ -z "$is_zbd" ] \|\| [ -c "$dev" ] \|\|
9ffe433d SK	91	! blkzone_reports_capacity "${dev}"; then
1ae82d67 SK	92	echo "$zone_size"
	93	return
	94	fi
	95
	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
	100	bs=$((bs / 2))
	101	done
	102	done < <(blkzone report "${dev}" \| sed -n "${sed_str}")
	103
	104	echo "$bs"
	105	}
	106
191d1d1a BVA	107	# Reports the starting sector and length of the first sequential zone of device
	108	# $1.
	109	first_sequential_zone() {
	110	local dev=$1
	111
6dcb098d	112	if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
191d1d1a	113	${blkzone} report "$dev" \|
c6950209	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' \|
191d1d1a BVA	115	{
	116	read -r starting_sector length &&
	117	# Convert from hex to decimal
	118	echo $((starting_sector)) $((length))
	119	}
	120	else
	121	${zbc_report_zones} "$dev" \|
c6950209	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' \|
191d1d1a BVA	123	head -n1
	124	fi
	125	}
	126
d7c7539f HH	127	# Reports the summed zone capacity of $1 number of zones starting from offset $2
	128	# on device $3.
	129	total_zone_capacity() {
	130	local nr_zones=$1
	131	local sector=$(($2 / 512))
	132	local dev=$3
	133	local capacity=0 num
	134	local grep_str
	135
	136	if [ -z "$is_zbd" ]; then
	137	# For regular block devices, handle zone size as zone capacity.
	138	echo $((zone_size * nr_zones))
	139	return
	140	fi
	141
	142	if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
	143	if blkzone_reports_capacity "${dev}"; then
	144	grep_str='cap \K[0-9a-zA-Z]*'
	145	else
	146	# If zone capacity is not reported, refer zone length.
	147	grep_str='len \K[0-9a-zA-Z]*'
	148	fi
	149	while read num; do
	150	capacity=$((capacity + num))
	151	done < <(${blkzone} report -c "$nr_zones" -o "$sector" "$dev" \|
	152	grep -Po "${grep_str}")
	153	else
	154	# ZBC devices do not have zone capacity. Use zone size.
	155	while read num; do
	156	capacity=$((capacity + num))
	157	done < <(${zbc_report_zones} -nz "$nr_zones" -start "$sector" \
	158	"$dev" \| grep -Po 'sector [0-9], \K[0-9]')
	159	fi
	160
	161	echo $((capacity * 512))
	162	}
	163
c6950209 DF	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() {
	167	local dev=$1
	168
	169	if [ -z "$is_zbd" ]; then
	170	echo 0
	171	return
	172	fi
	173
	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' \|
	177	head -n1 \|
	178	{
	179	read -r starting_sector &&
	180	# Convert from hex to decimal
	181	echo $((starting_sector))
	182	}
	183	else
	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' \|
	186	head -n1
	187	fi
	188	}
	189
	190	# Reports the starting sector and length of the last zone of device $1
	191	# that is not in offline (or similar) condition.
	192	last_online_zone() {
	193	local dev=$1
	194
	195	if [ -z "$is_zbd" ]; then
	196	echo 0
	197	return
	198	fi
	199
	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' \|
	203	tail -1 \|
	204	{
	205	read -r starting_sector &&
	206	# Convert from hex to decimal
	207	echo $((starting_sector))
	208	}
	209	else
	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' \|
	212	tail -1
	213	fi
	214	}
	215
e1315822 SK	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.
191d1d1a BVA	224	max_open_zones() {
191d1d1a BVA	225	local dev=$1
af26c9bf	226	local realdev syspath
191d1d1a	227
af26c9bf SK	228	realdev=$(readlink -f "$dev")
	229	syspath=/sys/block/${realdev##*/}/queue/max_open_zones
	230
	231	if [ -b "${realdev}" ] && [ -r "${syspath}" ]; then
	232	cat ${syspath}
	233	elif [ -n "${sg_inq}" ] && [ ! -n "${use_libzbc}" ]; then
e80190b4 SK	234	if ! ${sg_inq} -e --page=0xB6 --len=20 --hex "$dev" \
e80190b4 SK	235	> /dev/null 2>&1; then
e1315822 SK	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.
	238	echo 0
68ecd85e SK	239	else
	240	${sg_inq} -e --page=0xB6 --len=20 --hex "$dev" \| tail -1 \|
	241	{
	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}
	249	}
	250	fi
842fb796	251	elif [ -n "${use_libzbc}" ]; then
191d1d1a BVA	252	${zbc_report_zones} "$dev" \|
191d1d1a BVA	253	sed -n 's/^[[:blank:]]Maximum number of open sequential write required zones:[[:blank:]]//p'
842fb796 DF	254	else
842fb796 DF	255	echo 0
191d1d1a BVA	256	fi
	257	}
	258
1a5411cd SK	259	# If sysfs provides, get max_active_zones limit of the zoned block device.
	260	max_active_zones() {
	261	local dev=$1
	262	local sys_queue="/sys/block/${dev##*/}/queue/"
	263
	264	if [[ -e "$sys_queue/max_active_zones" ]]; then
	265	cat "$sys_queue/max_active_zones"
	266	return
	267	fi
	268	echo 0
	269	}
	270
557cfc51 SK	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"
	278	local -i size=0
	279
	280	if [[ -r "$sys_path/zone_write_granularity" ]]; then
	281	size=$(<"$sys_path/zone_write_granularity")
	282	fi
	283
	284	if ((size)); then
	285	echo "$size"
	286	elif (($(<"$sys_path/rotational"))); then
	287	cat "$sys_path/physical_block_size"
	288	else
	289	cat "$sys_path/logical_block_size"
	290	fi
	291	}
	292
7d5a66e1 DF	293	urswrz() {
	294	local dev=$1
	295
	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.
	301	echo 1
	302	else
	303	${sg_inq} -e --page=0xB6 --len=10 --hex "$dev" \| tail -1 \|
	304	{
	305	read -r offset b0 b1 b2 b3 b4 trailer && \
	306	echo $(( $b4 & 0x01 )) \|\| echo 0
	307	}
	308	fi
	309	else
	310	${zbc_info} "$dev" \|
	311	sed -n 's/^[[:blank:]].Read commands are \(un\)restricted/\1/p' \| grep -q ^ && echo 1 \|\| echo 0
	312	fi
	313	}
	314
6dcb098d DF	315	is_zbc() {
	316	local dev=$1
	317
	318	[[ -z "$(${zbc_info} "$dev" \| grep "is not a zoned block device")" ]]
	319	}
	320
557cfc51	321	zbc_physical_block_size() {
6dcb098d DF	322	local dev=$1
	323
	324	${zbc_info} "$dev" \|
557cfc51 SK	325	grep "physical blocks" \|
557cfc51 SK	326	sed -n 's/^[[:blank:]][0-9] physical blocks of[[:blank:]]*//p' \|
6dcb098d DF	327	sed 's/ B//'
	328	}
	329
	330	zbc_disk_sectors() {
	331	local dev=$1
	332
	333	zbc_info "$dev" \|
	334	grep "512-bytes sectors" \|
	335	sed -e 's/[[:blank:]]\([0-9]\)512-bytes sectors.*/\1/'
	336	}
	337
191d1d1a BVA	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
	340	# zones.
	341	reset_zone() {
	342	local dev=$1 offset=$2 sectors
	343
6dcb098d	344	if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then
191d1d1a	345	if [ "$offset" -lt 0 ]; then
63a52199	346	${blkzone} reset "$dev"
191d1d1a BVA	347	else
	348	${blkzone} reset -o "${offset}" -c 1 "$dev"
	349	fi
	350	else
	351	if [ "$offset" -lt 0 ]; then
3412afb7	352	${zbc_reset_zone} -all "$dev" >/dev/null
191d1d1a BVA	353	else
	354	${zbc_reset_zone} -sector "$dev" "${offset}" >/dev/null
	355	fi
	356	fi
	357	}
	358
00080a1e SK	359	# Close the zone on device $1 at offset $2. The offset must be specified in
	360	# units of 512 byte sectors.
	361	close_zone() {
	362	local dev=$1 offset=$2
	363
	364	if [ -n "${blkzone}" ] && [ -z "${use_libzbc}" ]; then
	365	${blkzone} close -o "${offset}" -c 1 "$dev"
	366	else
	367	${zbc_close_zone} -sector "$dev" "${offset}" >/dev/null
	368	fi
	369	}
	370
191d1d1a BVA	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
	373	fio_io() {
	374	sed -n 's/^[[:blank:]]'"$1"'., io=\([^[:blank:]]\)./\1/p' \|
	375	tail -n 1 \|
	376	(
	377	read -r io;
	378	# Parse <number>.<number><suffix> into n1, n2 and s. See also
	379	# num2str().
	380	shopt -s extglob
	381	n1=${io%${io##*([0-9])}}
	382	s=${io#${io%%*([a-zA-Z])}}
	383	n2=${io#${n1}}
	384	n2=${n2#.}
	385	n2=${n2%$s}000
	386	n2=${n2:0:3}
	387	case "$s" in
	388	KiB) m=10;;
	389	MiB) m=20;;
	390	GiB) m=30;;
	391	B) m=0;;
	392	*) return 1;;
	393	esac
	394	[ -n "$n1" ] \|\| return 1
	395	echo $(((n1 << m) + (n2 << m) / 1000))
	396	)
	397	}
	398
	399	fio_read() {
	400	fio_io 'READ:'
	401	}
	402
	403	fio_written() {
	404	fio_io 'WRITE:'
	405	}
	406
	407	fio_reset_count() {
1b412cb4 BVA	408	local count
	409
	410	count=$(sed -n 's/^.write:[^;]; \([0-9]*\) zone resets$/\1/p')
	411	echo "${count:-0}"
191d1d1a	412	}