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) | |
6dcb098d | 7 | zbc_info=$(type -p zbc_info 2>/dev/null) |
191d1d1a BVA |
8 | if [ -z "${blkzone}" ] && |
9 | { [ -z "${zbc_report_zones}" ] || [ -z "${zbc_reset_zone}" ]; }; then | |
10 | echo "Error: neither blkzone nor zbc_report_zones is available" | |
11 | exit 1 | |
12 | fi | |
13 | ||
6dcb098d DF |
14 | if [ -n "${use_libzbc}" ] && |
15 | { [ -z "${zbc_report_zones}" ] || [ -z "${zbc_reset_zone}" ] || | |
16 | [ -z "${zbc_info}" ]; }; then | |
17 | echo "Error: zbc_report_zones, or zbc_reset_zone or zbc_info is not available" | |
18 | echo "Error: reinstall libzbc tools" | |
19 | exit 1 | |
20 | fi | |
21 | ||
552e214c SK |
22 | blkzone_reports_capacity() { |
23 | local dev="${1}" | |
24 | ||
25 | [[ -n "${blkzone}" ]] && | |
26 | "${blkzone}" report -c 1 -o 0 "${dev}" | grep -q 'cap ' | |
27 | } | |
28 | ||
29 | # Whether or not $1 (/dev/...) is a NVME ZNS device. | |
30 | is_nvme_zns() { | |
31 | local s | |
32 | ||
33 | s=/sys/block/$(basename "${1}")/device/subsystem | |
34 | ||
35 | if [[ ! -h "${s}" || $(realpath "${s}") != /sys/class/nvme ]]; then | |
36 | return 1 | |
37 | fi | |
38 | ||
39 | [[ $(</sys/block/$(basename "${1}")/queue/zoned) == host-managed ]] | |
40 | } | |
41 | ||
42 | # Whether or not $1 (/dev/...) is a null_blk device with zone capacity smaller | |
43 | # than zone size. | |
44 | is_nullb_with_zone_cap() { | |
45 | local f | |
46 | ||
47 | f=/sys/kernel/config/nullb/$(basename "${1}") | |
48 | [[ -r "${f}/zone_capacity" && | |
49 | $(<"${f}/zone_capacity") -lt $(<"${f}/zone_size") ]] | |
50 | } | |
51 | ||
52 | # Check if blkzone is available and suitable for the test target device. If not | |
53 | # available, print error message and return 1. Otherwise return 0. | |
54 | check_blkzone() { | |
55 | local dev="${1}" | |
56 | ||
57 | # If the device supports zone capacity, mandate zone capacity report by | |
58 | # blkzone. | |
59 | if (is_nvme_zns "${dev}" || is_nullb_with_zone_cap "${dev}") && | |
60 | ! blkzone_reports_capacity "${dev}"; then | |
61 | echo "Error: blkzone does not report zone capacity" | |
62 | echo "Error: install latest util-linux with blkzone" | |
63 | return 1 | |
64 | fi | |
65 | } | |
66 | ||
191d1d1a BVA |
67 | # Reports the starting sector and length of the first sequential zone of device |
68 | # $1. | |
69 | first_sequential_zone() { | |
70 | local dev=$1 | |
71 | ||
6dcb098d | 72 | if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then |
191d1d1a | 73 | ${blkzone} report "$dev" | |
c6950209 | 74 | 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 |
75 | { |
76 | read -r starting_sector length && | |
77 | # Convert from hex to decimal | |
78 | echo $((starting_sector)) $((length)) | |
79 | } | |
80 | else | |
81 | ${zbc_report_zones} "$dev" | | |
c6950209 | 82 | 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 |
83 | head -n1 |
84 | fi | |
85 | } | |
86 | ||
d7c7539f HH |
87 | # Reports the summed zone capacity of $1 number of zones starting from offset $2 |
88 | # on device $3. | |
89 | total_zone_capacity() { | |
90 | local nr_zones=$1 | |
91 | local sector=$(($2 / 512)) | |
92 | local dev=$3 | |
93 | local capacity=0 num | |
94 | local grep_str | |
95 | ||
96 | if [ -z "$is_zbd" ]; then | |
97 | # For regular block devices, handle zone size as zone capacity. | |
98 | echo $((zone_size * nr_zones)) | |
99 | return | |
100 | fi | |
101 | ||
102 | if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then | |
103 | if blkzone_reports_capacity "${dev}"; then | |
104 | grep_str='cap \K[0-9a-zA-Z]*' | |
105 | else | |
106 | # If zone capacity is not reported, refer zone length. | |
107 | grep_str='len \K[0-9a-zA-Z]*' | |
108 | fi | |
109 | while read num; do | |
110 | capacity=$((capacity + num)) | |
111 | done < <(${blkzone} report -c "$nr_zones" -o "$sector" "$dev" | | |
112 | grep -Po "${grep_str}") | |
113 | else | |
114 | # ZBC devices do not have zone capacity. Use zone size. | |
115 | while read num; do | |
116 | capacity=$((capacity + num)) | |
117 | done < <(${zbc_report_zones} -nz "$nr_zones" -start "$sector" \ | |
118 | "$dev" | grep -Po 'sector [0-9]*, \K[0-9]*') | |
119 | fi | |
120 | ||
121 | echo $((capacity * 512)) | |
122 | } | |
123 | ||
c6950209 DF |
124 | # Reports the starting sector and length of the first zone of device $1 |
125 | # that is not in offline (or similar) condition. | |
126 | first_online_zone() { | |
127 | local dev=$1 | |
128 | ||
129 | if [ -z "$is_zbd" ]; then | |
130 | echo 0 | |
131 | return | |
132 | fi | |
133 | ||
134 | if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then | |
135 | ${blkzone} report "$dev" | | |
136 | 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' | | |
137 | head -n1 | | |
138 | { | |
139 | read -r starting_sector && | |
140 | # Convert from hex to decimal | |
141 | echo $((starting_sector)) | |
142 | } | |
143 | else | |
144 | ${zbc_report_zones} "$dev" | | |
145 | 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' | | |
146 | head -n1 | |
147 | fi | |
148 | } | |
149 | ||
150 | # Reports the starting sector and length of the last zone of device $1 | |
151 | # that is not in offline (or similar) condition. | |
152 | last_online_zone() { | |
153 | local dev=$1 | |
154 | ||
155 | if [ -z "$is_zbd" ]; then | |
156 | echo 0 | |
157 | return | |
158 | fi | |
159 | ||
160 | if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then | |
161 | ${blkzone} report "$dev" | | |
162 | 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' | | |
163 | tail -1 | | |
164 | { | |
165 | read -r starting_sector && | |
166 | # Convert from hex to decimal | |
167 | echo $((starting_sector)) | |
168 | } | |
169 | else | |
170 | ${zbc_report_zones} "$dev" | | |
171 | 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' | | |
172 | tail -1 | |
173 | fi | |
174 | } | |
175 | ||
191d1d1a BVA |
176 | max_open_zones() { |
177 | local dev=$1 | |
178 | ||
6dcb098d | 179 | if [ -n "${sg_inq}" ] && [ ! -n "${use_libzbc}" ]; then |
e80190b4 SK |
180 | if ! ${sg_inq} -e --page=0xB6 --len=20 --hex "$dev" \ |
181 | > /dev/null 2>&1; then | |
68ecd85e SK |
182 | # Non scsi device such as null_blk can not return max open zones. |
183 | # Use default value. | |
184 | echo 128 | |
185 | else | |
186 | ${sg_inq} -e --page=0xB6 --len=20 --hex "$dev" | tail -1 | | |
187 | { | |
188 | read -r offset b0 b1 b2 b3 trailer || return $? | |
189 | # Convert from hex to decimal | |
190 | max_nr_open_zones=$((0x${b0})) | |
191 | max_nr_open_zones=$((max_nr_open_zones * 256 + 0x${b1})) | |
192 | max_nr_open_zones=$((max_nr_open_zones * 256 + 0x${b2})) | |
193 | max_nr_open_zones=$((max_nr_open_zones * 256 + 0x${b3})) | |
194 | echo ${max_nr_open_zones} | |
195 | } | |
196 | fi | |
191d1d1a BVA |
197 | else |
198 | ${zbc_report_zones} "$dev" | | |
199 | sed -n 's/^[[:blank:]]*Maximum number of open sequential write required zones:[[:blank:]]*//p' | |
200 | fi | |
201 | } | |
202 | ||
6dcb098d DF |
203 | is_zbc() { |
204 | local dev=$1 | |
205 | ||
206 | [[ -z "$(${zbc_info} "$dev" | grep "is not a zoned block device")" ]] | |
207 | } | |
208 | ||
209 | zbc_logical_block_size() { | |
210 | local dev=$1 | |
211 | ||
212 | ${zbc_info} "$dev" | | |
213 | grep "logical blocks" | | |
214 | sed -n 's/^[[:blank:]]*[0-9]* logical blocks of[[:blank:]]*//p' | | |
215 | sed 's/ B//' | |
216 | } | |
217 | ||
218 | zbc_disk_sectors() { | |
219 | local dev=$1 | |
220 | ||
221 | zbc_info "$dev" | | |
222 | grep "512-bytes sectors" | | |
223 | sed -e 's/[[:blank:]]*\([0-9]*\)512-bytes sectors.*/\1/' | |
224 | } | |
225 | ||
191d1d1a BVA |
226 | # Reset the write pointer of one zone on device $1 at offset $2. The offset |
227 | # must be specified in units of 512 byte sectors. Offset -1 means reset all | |
228 | # zones. | |
229 | reset_zone() { | |
230 | local dev=$1 offset=$2 sectors | |
231 | ||
6dcb098d | 232 | if [ -n "${blkzone}" ] && [ ! -n "${use_libzbc}" ]; then |
191d1d1a | 233 | if [ "$offset" -lt 0 ]; then |
63a52199 | 234 | ${blkzone} reset "$dev" |
191d1d1a BVA |
235 | else |
236 | ${blkzone} reset -o "${offset}" -c 1 "$dev" | |
237 | fi | |
238 | else | |
239 | if [ "$offset" -lt 0 ]; then | |
3412afb7 | 240 | ${zbc_reset_zone} -all "$dev" >/dev/null |
191d1d1a BVA |
241 | else |
242 | ${zbc_reset_zone} -sector "$dev" "${offset}" >/dev/null | |
243 | fi | |
244 | fi | |
245 | } | |
246 | ||
247 | # Extract the number of bytes that have been transferred from a line like | |
248 | # READ: bw=6847KiB/s (7011kB/s), 6847KiB/s-6847KiB/s (7011kB/s-7011kB/s), io=257MiB (269MB), run=38406-38406msec | |
249 | fio_io() { | |
250 | sed -n 's/^[[:blank:]]*'"$1"'.*, io=\([^[:blank:]]*\).*/\1/p' | | |
251 | tail -n 1 | | |
252 | ( | |
253 | read -r io; | |
254 | # Parse <number>.<number><suffix> into n1, n2 and s. See also | |
255 | # num2str(). | |
256 | shopt -s extglob | |
257 | n1=${io%${io##*([0-9])}} | |
258 | s=${io#${io%%*([a-zA-Z])}} | |
259 | n2=${io#${n1}} | |
260 | n2=${n2#.} | |
261 | n2=${n2%$s}000 | |
262 | n2=${n2:0:3} | |
263 | case "$s" in | |
264 | KiB) m=10;; | |
265 | MiB) m=20;; | |
266 | GiB) m=30;; | |
267 | B) m=0;; | |
268 | *) return 1;; | |
269 | esac | |
270 | [ -n "$n1" ] || return 1 | |
271 | echo $(((n1 << m) + (n2 << m) / 1000)) | |
272 | ) | |
273 | } | |
274 | ||
275 | fio_read() { | |
276 | fio_io 'READ:' | |
277 | } | |
278 | ||
279 | fio_written() { | |
280 | fio_io 'WRITE:' | |
281 | } | |
282 | ||
283 | fio_reset_count() { | |
1b412cb4 BVA |
284 | local count |
285 | ||
286 | count=$(sed -n 's/^.*write:[^;]*; \([0-9]*\) zone resets$/\1/p') | |
287 | echo "${count:-0}" | |
191d1d1a | 288 | } |