Commit | Line | Data |
---|---|---|
191d1d1a BVA |
1 | #!/bin/bash |
2 | ||
68ecd85e SK |
3 | blkzone=$(type -p blkzone 2>/dev/null) |
4 | sg_inq=$(type -p sg_inq 2>/dev/null) | |
191d1d1a BVA |
5 | zbc_report_zones=$(type -p zbc_report_zones 2>/dev/null) |
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 |
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" ] || |
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() { |
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" \ |
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" | |
253 | sed -n 's/^[[:blank:]]*Maximum number of open sequential write required zones:[[:blank:]]*//p' | |
842fb796 DF |
254 | else |
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" | |
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 | } |