]>
Commit | Line | Data |
---|---|---|
34dc7c2f BB |
1 | /* |
2 | * CDDL HEADER START | |
3 | * | |
4 | * The contents of this file are subject to the terms of the | |
5 | * Common Development and Distribution License (the "License"). | |
6 | * You may not use this file except in compliance with the License. | |
7 | * | |
8 | * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE | |
9 | * or http://www.opensolaris.org/os/licensing. | |
10 | * See the License for the specific language governing permissions | |
11 | * and limitations under the License. | |
12 | * | |
13 | * When distributing Covered Code, include this CDDL HEADER in each | |
14 | * file and include the License file at usr/src/OPENSOLARIS.LICENSE. | |
15 | * If applicable, add the following below this CDDL HEADER, with the | |
16 | * fields enclosed by brackets "[]" replaced with your own identifying | |
17 | * information: Portions Copyright [yyyy] [name of copyright owner] | |
18 | * | |
19 | * CDDL HEADER END | |
20 | */ | |
21 | ||
22 | /* | |
428870ff | 23 | * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. |
a38718a6 | 24 | * Copyright 2011 Nexenta Systems, Inc. All rights reserved. |
64fc7762 | 25 | * Copyright (c) 2012, 2017 by Delphix. All rights reserved. |
9759c60f | 26 | * Copyright (c) 2013 by Saso Kiselkov. All rights reserved. |
e550644f BB |
27 | * Copyright (c) 2013, Joyent, Inc. All rights reserved. |
28 | * Copyright 2016 Toomas Soome <tsoome@me.com> | |
a38718a6 | 29 | */ |
34dc7c2f BB |
30 | |
31 | #ifndef _ZIO_H | |
32 | #define _ZIO_H | |
33 | ||
fcff0f35 | 34 | #include <sys/zio_priority.h> |
34dc7c2f BB |
35 | #include <sys/zfs_context.h> |
36 | #include <sys/spa.h> | |
37 | #include <sys/txg.h> | |
38 | #include <sys/avl.h> | |
34dc7c2f BB |
39 | #include <sys/fs/zfs.h> |
40 | #include <sys/zio_impl.h> | |
41 | ||
42 | #ifdef __cplusplus | |
43 | extern "C" { | |
44 | #endif | |
45 | ||
428870ff BB |
46 | /* |
47 | * Embedded checksum | |
48 | */ | |
49 | #define ZEC_MAGIC 0x210da7ab10c7a11ULL | |
34dc7c2f | 50 | |
428870ff BB |
51 | typedef struct zio_eck { |
52 | uint64_t zec_magic; /* for validation, endianness */ | |
53 | zio_cksum_t zec_cksum; /* 256-bit checksum */ | |
54 | } zio_eck_t; | |
34dc7c2f BB |
55 | |
56 | /* | |
57 | * Gang block headers are self-checksumming and contain an array | |
58 | * of block pointers. | |
59 | */ | |
60 | #define SPA_GANGBLOCKSIZE SPA_MINBLOCKSIZE | |
61 | #define SPA_GBH_NBLKPTRS ((SPA_GANGBLOCKSIZE - \ | |
428870ff | 62 | sizeof (zio_eck_t)) / sizeof (blkptr_t)) |
34dc7c2f | 63 | #define SPA_GBH_FILLER ((SPA_GANGBLOCKSIZE - \ |
428870ff | 64 | sizeof (zio_eck_t) - \ |
34dc7c2f BB |
65 | (SPA_GBH_NBLKPTRS * sizeof (blkptr_t))) /\ |
66 | sizeof (uint64_t)) | |
67 | ||
34dc7c2f BB |
68 | typedef struct zio_gbh { |
69 | blkptr_t zg_blkptr[SPA_GBH_NBLKPTRS]; | |
70 | uint64_t zg_filler[SPA_GBH_FILLER]; | |
428870ff | 71 | zio_eck_t zg_tail; |
34dc7c2f BB |
72 | } zio_gbh_phys_t; |
73 | ||
74 | enum zio_checksum { | |
75 | ZIO_CHECKSUM_INHERIT = 0, | |
76 | ZIO_CHECKSUM_ON, | |
77 | ZIO_CHECKSUM_OFF, | |
78 | ZIO_CHECKSUM_LABEL, | |
79 | ZIO_CHECKSUM_GANG_HEADER, | |
80 | ZIO_CHECKSUM_ZILOG, | |
81 | ZIO_CHECKSUM_FLETCHER_2, | |
82 | ZIO_CHECKSUM_FLETCHER_4, | |
83 | ZIO_CHECKSUM_SHA256, | |
428870ff | 84 | ZIO_CHECKSUM_ZILOG2, |
3c67d83a TH |
85 | ZIO_CHECKSUM_NOPARITY, |
86 | ZIO_CHECKSUM_SHA512, | |
87 | ZIO_CHECKSUM_SKEIN, | |
88 | ZIO_CHECKSUM_EDONR, | |
34dc7c2f BB |
89 | ZIO_CHECKSUM_FUNCTIONS |
90 | }; | |
91 | ||
9b67f605 MA |
92 | /* |
93 | * The number of "legacy" compression functions which can be set on individual | |
94 | * objects. | |
95 | */ | |
96 | #define ZIO_CHECKSUM_LEGACY_FUNCTIONS ZIO_CHECKSUM_ZILOG2 | |
97 | ||
9babb374 | 98 | #define ZIO_CHECKSUM_ON_VALUE ZIO_CHECKSUM_FLETCHER_4 |
34dc7c2f BB |
99 | #define ZIO_CHECKSUM_DEFAULT ZIO_CHECKSUM_ON |
100 | ||
428870ff BB |
101 | #define ZIO_CHECKSUM_MASK 0xffULL |
102 | #define ZIO_CHECKSUM_VERIFY (1 << 8) | |
103 | ||
104 | #define ZIO_DEDUPCHECKSUM ZIO_CHECKSUM_SHA256 | |
105 | #define ZIO_DEDUPDITTO_MIN 100 | |
106 | ||
b5256303 TC |
107 | /* supported encryption algorithms */ |
108 | enum zio_encrypt { | |
109 | ZIO_CRYPT_INHERIT = 0, | |
110 | ZIO_CRYPT_ON, | |
111 | ZIO_CRYPT_OFF, | |
112 | ZIO_CRYPT_AES_128_CCM, | |
113 | ZIO_CRYPT_AES_192_CCM, | |
114 | ZIO_CRYPT_AES_256_CCM, | |
115 | ZIO_CRYPT_AES_128_GCM, | |
116 | ZIO_CRYPT_AES_192_GCM, | |
117 | ZIO_CRYPT_AES_256_GCM, | |
118 | ZIO_CRYPT_FUNCTIONS | |
119 | }; | |
120 | ||
121 | #define ZIO_CRYPT_ON_VALUE ZIO_CRYPT_AES_256_CCM | |
122 | #define ZIO_CRYPT_DEFAULT ZIO_CRYPT_OFF | |
123 | ||
124 | /* macros defining encryption lengths */ | |
125 | #define ZIO_OBJSET_MAC_LEN 32 | |
126 | #define ZIO_DATA_IV_LEN 12 | |
127 | #define ZIO_DATA_SALT_LEN 8 | |
128 | #define ZIO_DATA_MAC_LEN 16 | |
129 | ||
9b67f605 MA |
130 | /* |
131 | * The number of "legacy" compression functions which can be set on individual | |
132 | * objects. | |
133 | */ | |
134 | #define ZIO_COMPRESS_LEGACY_FUNCTIONS ZIO_COMPRESS_LZ4 | |
135 | ||
99197f03 JG |
136 | /* |
137 | * The meaning of "compress = on" selected by the compression features enabled | |
138 | * on a given pool. | |
139 | */ | |
140 | #define ZIO_COMPRESS_LEGACY_ON_VALUE ZIO_COMPRESS_LZJB | |
141 | #define ZIO_COMPRESS_LZ4_ON_VALUE ZIO_COMPRESS_LZ4 | |
142 | ||
143 | #define ZIO_COMPRESS_DEFAULT ZIO_COMPRESS_OFF | |
34dc7c2f | 144 | |
428870ff BB |
145 | #define BOOTFS_COMPRESS_VALID(compress) \ |
146 | ((compress) == ZIO_COMPRESS_LZJB || \ | |
9759c60f | 147 | (compress) == ZIO_COMPRESS_LZ4 || \ |
8aab1218 TS |
148 | (compress) == ZIO_COMPRESS_GZIP_1 || \ |
149 | (compress) == ZIO_COMPRESS_GZIP_2 || \ | |
150 | (compress) == ZIO_COMPRESS_GZIP_3 || \ | |
151 | (compress) == ZIO_COMPRESS_GZIP_4 || \ | |
152 | (compress) == ZIO_COMPRESS_GZIP_5 || \ | |
153 | (compress) == ZIO_COMPRESS_GZIP_6 || \ | |
154 | (compress) == ZIO_COMPRESS_GZIP_7 || \ | |
155 | (compress) == ZIO_COMPRESS_GZIP_8 || \ | |
156 | (compress) == ZIO_COMPRESS_GZIP_9 || \ | |
157 | (compress) == ZIO_COMPRESS_ZLE || \ | |
99197f03 | 158 | (compress) == ZIO_COMPRESS_ON || \ |
428870ff BB |
159 | (compress) == ZIO_COMPRESS_OFF) |
160 | ||
a69052be BB |
161 | /* |
162 | * Default Linux timeout for a sd device. | |
163 | */ | |
d1d7e268 | 164 | #define ZIO_DELAY_MAX (30 * MILLISEC) |
a69052be | 165 | |
34dc7c2f BB |
166 | #define ZIO_FAILURE_MODE_WAIT 0 |
167 | #define ZIO_FAILURE_MODE_CONTINUE 1 | |
168 | #define ZIO_FAILURE_MODE_PANIC 2 | |
169 | ||
428870ff BB |
170 | enum zio_flag { |
171 | /* | |
172 | * Flags inherited by gang, ddt, and vdev children, | |
173 | * and that must be equal for two zios to aggregate | |
174 | */ | |
175 | ZIO_FLAG_DONT_AGGREGATE = 1 << 0, | |
176 | ZIO_FLAG_IO_REPAIR = 1 << 1, | |
177 | ZIO_FLAG_SELF_HEAL = 1 << 2, | |
178 | ZIO_FLAG_RESILVER = 1 << 3, | |
179 | ZIO_FLAG_SCRUB = 1 << 4, | |
572e2857 | 180 | ZIO_FLAG_SCAN_THREAD = 1 << 5, |
b02fe35d | 181 | ZIO_FLAG_PHYSICAL = 1 << 6, |
428870ff BB |
182 | |
183 | #define ZIO_FLAG_AGG_INHERIT (ZIO_FLAG_CANFAIL - 1) | |
184 | ||
185 | /* | |
186 | * Flags inherited by ddt, gang, and vdev children. | |
187 | */ | |
b02fe35d AR |
188 | ZIO_FLAG_CANFAIL = 1 << 7, /* must be first for INHERIT */ |
189 | ZIO_FLAG_SPECULATIVE = 1 << 8, | |
190 | ZIO_FLAG_CONFIG_WRITER = 1 << 9, | |
191 | ZIO_FLAG_DONT_RETRY = 1 << 10, | |
192 | ZIO_FLAG_DONT_CACHE = 1 << 11, | |
193 | ZIO_FLAG_NODATA = 1 << 12, | |
194 | ZIO_FLAG_INDUCE_DAMAGE = 1 << 13, | |
3dfb57a3 | 195 | ZIO_FLAG_IO_ALLOCATING = 1 << 14, |
428870ff BB |
196 | |
197 | #define ZIO_FLAG_DDT_INHERIT (ZIO_FLAG_IO_RETRY - 1) | |
198 | #define ZIO_FLAG_GANG_INHERIT (ZIO_FLAG_IO_RETRY - 1) | |
199 | ||
200 | /* | |
201 | * Flags inherited by vdev children. | |
202 | */ | |
3dfb57a3 DB |
203 | ZIO_FLAG_IO_RETRY = 1 << 15, /* must be first for INHERIT */ |
204 | ZIO_FLAG_PROBE = 1 << 16, | |
205 | ZIO_FLAG_TRYHARD = 1 << 17, | |
206 | ZIO_FLAG_OPTIONAL = 1 << 18, | |
428870ff BB |
207 | |
208 | #define ZIO_FLAG_VDEV_INHERIT (ZIO_FLAG_DONT_QUEUE - 1) | |
209 | ||
210 | /* | |
211 | * Flags not inherited by any children. | |
212 | */ | |
3dfb57a3 DB |
213 | ZIO_FLAG_DONT_QUEUE = 1 << 19, /* must be first for INHERIT */ |
214 | ZIO_FLAG_DONT_PROPAGATE = 1 << 20, | |
215 | ZIO_FLAG_IO_BYPASS = 1 << 21, | |
216 | ZIO_FLAG_IO_REWRITE = 1 << 22, | |
b5256303 TC |
217 | ZIO_FLAG_RAW_COMPRESS = 1 << 23, |
218 | ZIO_FLAG_RAW_ENCRYPT = 1 << 24, | |
219 | ZIO_FLAG_GANG_CHILD = 1 << 25, | |
220 | ZIO_FLAG_DDT_CHILD = 1 << 26, | |
221 | ZIO_FLAG_GODFATHER = 1 << 27, | |
222 | ZIO_FLAG_NOPWRITE = 1 << 28, | |
223 | ZIO_FLAG_REEXECUTED = 1 << 29, | |
224 | ZIO_FLAG_DELEGATED = 1 << 30, | |
225 | ZIO_FLAG_FASTWRITE = 1 << 31, | |
428870ff BB |
226 | }; |
227 | ||
228 | #define ZIO_FLAG_MUSTSUCCEED 0 | |
b5256303 | 229 | #define ZIO_FLAG_RAW (ZIO_FLAG_RAW_COMPRESS | ZIO_FLAG_RAW_ENCRYPT) |
428870ff BB |
230 | |
231 | #define ZIO_DDT_CHILD_FLAGS(zio) \ | |
232 | (((zio)->io_flags & ZIO_FLAG_DDT_INHERIT) | \ | |
233 | ZIO_FLAG_DDT_CHILD | ZIO_FLAG_CANFAIL) | |
234 | ||
b128c09f BB |
235 | #define ZIO_GANG_CHILD_FLAGS(zio) \ |
236 | (((zio)->io_flags & ZIO_FLAG_GANG_INHERIT) | \ | |
237 | ZIO_FLAG_GANG_CHILD | ZIO_FLAG_CANFAIL) | |
238 | ||
428870ff BB |
239 | #define ZIO_VDEV_CHILD_FLAGS(zio) \ |
240 | (((zio)->io_flags & ZIO_FLAG_VDEV_INHERIT) | \ | |
241 | ZIO_FLAG_CANFAIL) | |
242 | ||
b128c09f BB |
243 | enum zio_child { |
244 | ZIO_CHILD_VDEV = 0, | |
245 | ZIO_CHILD_GANG, | |
428870ff | 246 | ZIO_CHILD_DDT, |
b128c09f BB |
247 | ZIO_CHILD_LOGICAL, |
248 | ZIO_CHILD_TYPES | |
249 | }; | |
250 | ||
251 | enum zio_wait_type { | |
252 | ZIO_WAIT_READY = 0, | |
253 | ZIO_WAIT_DONE, | |
254 | ZIO_WAIT_TYPES | |
255 | }; | |
256 | ||
34dc7c2f BB |
257 | /* |
258 | * We'll take the unused errnos, 'EBADE' and 'EBADR' (from the Convergent | |
259 | * graveyard) to indicate checksum errors and fragmentation. | |
260 | */ | |
261 | #define ECKSUM EBADE | |
262 | #define EFRAGS EBADR | |
263 | ||
34dc7c2f BB |
264 | typedef void zio_done_func_t(zio_t *zio); |
265 | ||
3dfb57a3 | 266 | extern int zio_dva_throttle_enabled; |
e8b96c60 | 267 | extern const char *zio_type_name[ZIO_TYPES]; |
34dc7c2f BB |
268 | |
269 | /* | |
270 | * A bookmark is a four-tuple <objset, object, level, blkid> that uniquely | |
271 | * identifies any block in the pool. By convention, the meta-objset (MOS) | |
428870ff BB |
272 | * is objset 0, and the meta-dnode is object 0. This covers all blocks |
273 | * except root blocks and ZIL blocks, which are defined as follows: | |
34dc7c2f | 274 | * |
428870ff BB |
275 | * Root blocks (objset_phys_t) are object 0, level -1: <objset, 0, -1, 0>. |
276 | * ZIL blocks are bookmarked <objset, 0, -2, blkid == ZIL sequence number>. | |
277 | * dmu_sync()ed ZIL data blocks are bookmarked <objset, object, -2, blkid>. | |
fcff0f35 | 278 | * dnode visit bookmarks are <objset, object id of dnode, -3, 0>. |
34dc7c2f | 279 | * |
428870ff BB |
280 | * Note: this structure is called a bookmark because its original purpose |
281 | * was to remember where to resume a pool-wide traverse. | |
34dc7c2f | 282 | * |
5dbd68a3 MA |
283 | * Note: this structure is passed between userland and the kernel, and is |
284 | * stored on disk (by virtue of being incorporated into other on-disk | |
285 | * structures, e.g. dsl_scan_phys_t). | |
34dc7c2f | 286 | */ |
5dbd68a3 | 287 | struct zbookmark_phys { |
34dc7c2f BB |
288 | uint64_t zb_objset; |
289 | uint64_t zb_object; | |
290 | int64_t zb_level; | |
291 | uint64_t zb_blkid; | |
1421c891 | 292 | }; |
34dc7c2f | 293 | |
428870ff BB |
294 | #define SET_BOOKMARK(zb, objset, object, level, blkid) \ |
295 | { \ | |
296 | (zb)->zb_objset = objset; \ | |
297 | (zb)->zb_object = object; \ | |
298 | (zb)->zb_level = level; \ | |
299 | (zb)->zb_blkid = blkid; \ | |
300 | } | |
301 | ||
302 | #define ZB_DESTROYED_OBJSET (-1ULL) | |
303 | ||
304 | #define ZB_ROOT_OBJECT (0ULL) | |
305 | #define ZB_ROOT_LEVEL (-1LL) | |
306 | #define ZB_ROOT_BLKID (0ULL) | |
307 | ||
308 | #define ZB_ZIL_OBJECT (0ULL) | |
309 | #define ZB_ZIL_LEVEL (-2LL) | |
310 | ||
fcff0f35 PD |
311 | #define ZB_DNODE_LEVEL (-3LL) |
312 | #define ZB_DNODE_BLKID (0ULL) | |
313 | ||
9ae529ec CS |
314 | #define ZB_IS_ZERO(zb) \ |
315 | ((zb)->zb_objset == 0 && (zb)->zb_object == 0 && \ | |
316 | (zb)->zb_level == 0 && (zb)->zb_blkid == 0) | |
317 | #define ZB_IS_ROOT(zb) \ | |
318 | ((zb)->zb_object == ZB_ROOT_OBJECT && \ | |
319 | (zb)->zb_level == ZB_ROOT_LEVEL && \ | |
320 | (zb)->zb_blkid == ZB_ROOT_BLKID) | |
321 | ||
b128c09f BB |
322 | typedef struct zio_prop { |
323 | enum zio_checksum zp_checksum; | |
324 | enum zio_compress zp_compress; | |
325 | dmu_object_type_t zp_type; | |
326 | uint8_t zp_level; | |
428870ff | 327 | uint8_t zp_copies; |
03c6040b GW |
328 | boolean_t zp_dedup; |
329 | boolean_t zp_dedup_verify; | |
330 | boolean_t zp_nopwrite; | |
b5256303 TC |
331 | boolean_t zp_encrypt; |
332 | boolean_t zp_byteorder; | |
333 | uint8_t zp_salt[ZIO_DATA_SALT_LEN]; | |
334 | uint8_t zp_iv[ZIO_DATA_IV_LEN]; | |
335 | uint8_t zp_mac[ZIO_DATA_MAC_LEN]; | |
b128c09f BB |
336 | } zio_prop_t; |
337 | ||
428870ff BB |
338 | typedef struct zio_cksum_report zio_cksum_report_t; |
339 | ||
340 | typedef void zio_cksum_finish_f(zio_cksum_report_t *rep, | |
84c07ada | 341 | const abd_t *good_data); |
428870ff BB |
342 | typedef void zio_cksum_free_f(void *cbdata, size_t size); |
343 | ||
344 | struct zio_bad_cksum; /* defined in zio_checksum.h */ | |
9ae529ec | 345 | struct dnode_phys; |
a6255b7f | 346 | struct abd; |
428870ff BB |
347 | |
348 | struct zio_cksum_report { | |
349 | struct zio_cksum_report *zcr_next; | |
350 | nvlist_t *zcr_ereport; | |
351 | nvlist_t *zcr_detector; | |
352 | void *zcr_cbdata; | |
353 | size_t zcr_cbinfo; /* passed to zcr_free() */ | |
354 | uint64_t zcr_align; | |
355 | uint64_t zcr_length; | |
356 | zio_cksum_finish_f *zcr_finish; | |
357 | zio_cksum_free_f *zcr_free; | |
358 | ||
359 | /* internal use only */ | |
360 | struct zio_bad_cksum *zcr_ckinfo; /* information from failure */ | |
361 | }; | |
362 | ||
363 | typedef void zio_vsd_cksum_report_f(zio_t *zio, zio_cksum_report_t *zcr, | |
364 | void *arg); | |
365 | ||
366 | zio_vsd_cksum_report_f zio_vsd_default_cksum_report; | |
367 | ||
368 | typedef struct zio_vsd_ops { | |
369 | zio_done_func_t *vsd_free; | |
370 | zio_vsd_cksum_report_f *vsd_cksum_report; | |
371 | } zio_vsd_ops_t; | |
372 | ||
b128c09f BB |
373 | typedef struct zio_gang_node { |
374 | zio_gbh_phys_t *gn_gbh; | |
375 | struct zio_gang_node *gn_child[SPA_GBH_NBLKPTRS]; | |
376 | } zio_gang_node_t; | |
377 | ||
378 | typedef zio_t *zio_gang_issue_func_t(zio_t *zio, blkptr_t *bp, | |
a6255b7f | 379 | zio_gang_node_t *gn, struct abd *data, uint64_t offset); |
b128c09f | 380 | |
a6255b7f | 381 | typedef void zio_transform_func_t(zio_t *zio, struct abd *data, uint64_t size); |
b128c09f BB |
382 | |
383 | typedef struct zio_transform { | |
a6255b7f | 384 | struct abd *zt_orig_abd; |
b128c09f BB |
385 | uint64_t zt_orig_size; |
386 | uint64_t zt_bufsize; | |
387 | zio_transform_func_t *zt_transform; | |
388 | struct zio_transform *zt_next; | |
389 | } zio_transform_t; | |
390 | ||
391 | typedef int zio_pipe_stage_t(zio_t *zio); | |
392 | ||
393 | /* | |
394 | * The io_reexecute flags are distinct from io_flags because the child must | |
395 | * be able to propagate them to the parent. The normal io_flags are local | |
396 | * to the zio, not protected by any lock, and not modifiable by children; | |
397 | * the reexecute flags are protected by io_lock, modifiable by children, | |
398 | * and always propagated -- even when ZIO_FLAG_DONT_PROPAGATE is set. | |
399 | */ | |
400 | #define ZIO_REEXECUTE_NOW 0x01 | |
401 | #define ZIO_REEXECUTE_SUSPEND 0x02 | |
402 | ||
4e21fd06 DB |
403 | typedef struct zio_alloc_list { |
404 | list_t zal_list; | |
405 | uint64_t zal_size; | |
406 | } zio_alloc_list_t; | |
407 | ||
d164b209 BB |
408 | typedef struct zio_link { |
409 | zio_t *zl_parent; | |
410 | zio_t *zl_child; | |
411 | list_node_t zl_parent_node; | |
412 | list_node_t zl_child_node; | |
413 | } zio_link_t; | |
414 | ||
34dc7c2f BB |
415 | struct zio { |
416 | /* Core information about this I/O */ | |
5dbd68a3 | 417 | zbookmark_phys_t io_bookmark; |
b128c09f BB |
418 | zio_prop_t io_prop; |
419 | zio_type_t io_type; | |
420 | enum zio_child io_child_type; | |
421 | int io_cmd; | |
e8b96c60 | 422 | zio_priority_t io_priority; |
b128c09f | 423 | uint8_t io_reexecute; |
d164b209 | 424 | uint8_t io_state[ZIO_WAIT_TYPES]; |
34dc7c2f | 425 | uint64_t io_txg; |
b128c09f | 426 | spa_t *io_spa; |
34dc7c2f | 427 | blkptr_t *io_bp; |
428870ff | 428 | blkptr_t *io_bp_override; |
34dc7c2f | 429 | blkptr_t io_bp_copy; |
d164b209 BB |
430 | list_t io_parent_list; |
431 | list_t io_child_list; | |
34dc7c2f | 432 | zio_t *io_logical; |
b128c09f | 433 | zio_transform_t *io_transform_stack; |
34dc7c2f BB |
434 | |
435 | /* Callback info */ | |
bc77ba73 PD |
436 | zio_done_func_t *io_ready; |
437 | zio_done_func_t *io_children_ready; | |
e8b96c60 | 438 | zio_done_func_t *io_physdone; |
34dc7c2f BB |
439 | zio_done_func_t *io_done; |
440 | void *io_private; | |
428870ff | 441 | int64_t io_prev_space_delta; /* DMU private */ |
34dc7c2f | 442 | blkptr_t io_bp_orig; |
2aa34383 DK |
443 | /* io_lsize != io_orig_size iff this is a raw write */ |
444 | uint64_t io_lsize; | |
34dc7c2f BB |
445 | |
446 | /* Data represented by this I/O */ | |
a6255b7f DQ |
447 | struct abd *io_abd; |
448 | struct abd *io_orig_abd; | |
34dc7c2f | 449 | uint64_t io_size; |
428870ff | 450 | uint64_t io_orig_size; |
34dc7c2f BB |
451 | |
452 | /* Stuff for the vdev stack */ | |
453 | vdev_t *io_vd; | |
454 | void *io_vsd; | |
428870ff BB |
455 | const zio_vsd_ops_t *io_vsd_ops; |
456 | ||
34dc7c2f | 457 | uint64_t io_offset; |
cb682a17 | 458 | hrtime_t io_timestamp; /* submitted at */ |
3dfb57a3 | 459 | hrtime_t io_queued_timestamp; |
26ef0cc7 | 460 | hrtime_t io_target_timestamp; |
cb682a17 | 461 | hrtime_t io_delta; /* vdev queue service delta */ |
193a37cb TH |
462 | hrtime_t io_delay; /* Device access time (disk or */ |
463 | /* file). */ | |
e8b96c60 | 464 | avl_node_t io_queue_node; |
ec8501ee | 465 | avl_node_t io_offset_node; |
3dfb57a3 | 466 | avl_node_t io_alloc_node; |
4e21fd06 | 467 | zio_alloc_list_t io_alloc_list; |
34dc7c2f BB |
468 | |
469 | /* Internal pipeline state */ | |
428870ff BB |
470 | enum zio_flag io_flags; |
471 | enum zio_stage io_stage; | |
472 | enum zio_stage io_pipeline; | |
473 | enum zio_flag io_orig_flags; | |
474 | enum zio_stage io_orig_stage; | |
475 | enum zio_stage io_orig_pipeline; | |
3dfb57a3 | 476 | enum zio_stage io_pipeline_trace; |
b128c09f BB |
477 | int io_error; |
478 | int io_child_error[ZIO_CHILD_TYPES]; | |
479 | uint64_t io_children[ZIO_CHILD_TYPES][ZIO_WAIT_TYPES]; | |
428870ff | 480 | uint64_t io_child_count; |
e8b96c60 | 481 | uint64_t io_phys_children; |
428870ff | 482 | uint64_t io_parent_count; |
b128c09f | 483 | uint64_t *io_stall; |
9babb374 | 484 | zio_t *io_gang_leader; |
b128c09f BB |
485 | zio_gang_node_t *io_gang_tree; |
486 | void *io_executor; | |
34dc7c2f BB |
487 | void *io_waiter; |
488 | kmutex_t io_lock; | |
489 | kcondvar_t io_cv; | |
490 | ||
491 | /* FMA state */ | |
428870ff | 492 | zio_cksum_report_t *io_cksum_report; |
34dc7c2f | 493 | uint64_t io_ena; |
a38718a6 GA |
494 | |
495 | /* Taskq dispatching state */ | |
496 | taskq_ent_t io_tqent; | |
34dc7c2f BB |
497 | }; |
498 | ||
64fc7762 | 499 | extern int zio_bookmark_compare(const void *, const void *); |
3dfb57a3 | 500 | |
d164b209 | 501 | extern zio_t *zio_null(zio_t *pio, spa_t *spa, vdev_t *vd, |
428870ff | 502 | zio_done_func_t *done, void *private, enum zio_flag flags); |
34dc7c2f BB |
503 | |
504 | extern zio_t *zio_root(spa_t *spa, | |
428870ff | 505 | zio_done_func_t *done, void *private, enum zio_flag flags); |
34dc7c2f | 506 | |
a6255b7f DQ |
507 | extern zio_t *zio_read(zio_t *pio, spa_t *spa, const blkptr_t *bp, |
508 | struct abd *data, uint64_t lsize, zio_done_func_t *done, void *private, | |
5dbd68a3 | 509 | zio_priority_t priority, enum zio_flag flags, const zbookmark_phys_t *zb); |
34dc7c2f | 510 | |
b128c09f | 511 | extern zio_t *zio_write(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, |
a6255b7f | 512 | struct abd *data, uint64_t size, uint64_t psize, const zio_prop_t *zp, |
bc77ba73 PD |
513 | zio_done_func_t *ready, zio_done_func_t *children_ready, |
514 | zio_done_func_t *physdone, zio_done_func_t *done, | |
515 | void *private, zio_priority_t priority, enum zio_flag flags, | |
516 | const zbookmark_phys_t *zb); | |
34dc7c2f | 517 | |
b128c09f | 518 | extern zio_t *zio_rewrite(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, |
a6255b7f | 519 | struct abd *data, uint64_t size, zio_done_func_t *done, void *private, |
5dbd68a3 | 520 | zio_priority_t priority, enum zio_flag flags, zbookmark_phys_t *zb); |
b128c09f | 521 | |
03c6040b GW |
522 | extern void zio_write_override(zio_t *zio, blkptr_t *bp, int copies, |
523 | boolean_t nopwrite); | |
34dc7c2f | 524 | |
428870ff | 525 | extern void zio_free(spa_t *spa, uint64_t txg, const blkptr_t *bp); |
34dc7c2f | 526 | |
428870ff BB |
527 | extern zio_t *zio_claim(zio_t *pio, spa_t *spa, uint64_t txg, |
528 | const blkptr_t *bp, | |
529 | zio_done_func_t *done, void *private, enum zio_flag flags); | |
34dc7c2f BB |
530 | |
531 | extern zio_t *zio_ioctl(zio_t *pio, spa_t *spa, vdev_t *vd, int cmd, | |
e8b96c60 | 532 | zio_done_func_t *done, void *private, enum zio_flag flags); |
34dc7c2f BB |
533 | |
534 | extern zio_t *zio_read_phys(zio_t *pio, vdev_t *vd, uint64_t offset, | |
a6255b7f | 535 | uint64_t size, struct abd *data, int checksum, |
e8b96c60 MA |
536 | zio_done_func_t *done, void *private, zio_priority_t priority, |
537 | enum zio_flag flags, boolean_t labels); | |
34dc7c2f BB |
538 | |
539 | extern zio_t *zio_write_phys(zio_t *pio, vdev_t *vd, uint64_t offset, | |
a6255b7f | 540 | uint64_t size, struct abd *data, int checksum, |
e8b96c60 MA |
541 | zio_done_func_t *done, void *private, zio_priority_t priority, |
542 | enum zio_flag flags, boolean_t labels); | |
34dc7c2f | 543 | |
428870ff BB |
544 | extern zio_t *zio_free_sync(zio_t *pio, spa_t *spa, uint64_t txg, |
545 | const blkptr_t *bp, enum zio_flag flags); | |
546 | ||
b5256303 TC |
547 | extern int zio_alloc_zil(spa_t *spa, objset_t *os, uint64_t txg, |
548 | blkptr_t *new_bp, uint64_t size, boolean_t *slog); | |
428870ff | 549 | extern void zio_free_zil(spa_t *spa, uint64_t txg, blkptr_t *bp); |
34dc7c2f | 550 | extern void zio_flush(zio_t *zio, vdev_t *vd); |
428870ff | 551 | extern void zio_shrink(zio_t *zio, uint64_t size); |
34dc7c2f BB |
552 | |
553 | extern int zio_wait(zio_t *zio); | |
554 | extern void zio_nowait(zio_t *zio); | |
555 | extern void zio_execute(zio_t *zio); | |
556 | extern void zio_interrupt(zio_t *zio); | |
26ef0cc7 TH |
557 | extern void zio_delay_init(zio_t *zio); |
558 | extern void zio_delay_interrupt(zio_t *zio); | |
34dc7c2f | 559 | |
3dfb57a3 DB |
560 | extern zio_t *zio_walk_parents(zio_t *cio, zio_link_t **); |
561 | extern zio_t *zio_walk_children(zio_t *pio, zio_link_t **); | |
d164b209 BB |
562 | extern zio_t *zio_unique_parent(zio_t *cio); |
563 | extern void zio_add_child(zio_t *pio, zio_t *cio); | |
564 | ||
34dc7c2f BB |
565 | extern void *zio_buf_alloc(size_t size); |
566 | extern void zio_buf_free(void *buf, size_t size); | |
567 | extern void *zio_data_buf_alloc(size_t size); | |
568 | extern void zio_data_buf_free(void *buf, size_t size); | |
569 | ||
a6255b7f | 570 | extern void zio_push_transform(zio_t *zio, struct abd *abd, uint64_t size, |
d3c2ae1c GW |
571 | uint64_t bufsize, zio_transform_func_t *transform); |
572 | extern void zio_pop_transforms(zio_t *zio); | |
573 | ||
34dc7c2f BB |
574 | extern void zio_resubmit_stage_async(void *); |
575 | ||
34dc7c2f | 576 | extern zio_t *zio_vdev_child_io(zio_t *zio, blkptr_t *bp, vdev_t *vd, |
a6255b7f | 577 | uint64_t offset, struct abd *data, uint64_t size, int type, |
e8b96c60 MA |
578 | zio_priority_t priority, enum zio_flag flags, |
579 | zio_done_func_t *done, void *private); | |
34dc7c2f | 580 | |
b128c09f | 581 | extern zio_t *zio_vdev_delegated_io(vdev_t *vd, uint64_t offset, |
a6255b7f | 582 | struct abd *data, uint64_t size, int type, zio_priority_t priority, |
428870ff | 583 | enum zio_flag flags, zio_done_func_t *done, void *private); |
b128c09f | 584 | |
34dc7c2f BB |
585 | extern void zio_vdev_io_bypass(zio_t *zio); |
586 | extern void zio_vdev_io_reissue(zio_t *zio); | |
587 | extern void zio_vdev_io_redone(zio_t *zio); | |
588 | ||
589 | extern void zio_checksum_verified(zio_t *zio); | |
b128c09f | 590 | extern int zio_worst_error(int e1, int e2); |
34dc7c2f | 591 | |
428870ff BB |
592 | extern enum zio_checksum zio_checksum_select(enum zio_checksum child, |
593 | enum zio_checksum parent); | |
594 | extern enum zio_checksum zio_checksum_dedup_select(spa_t *spa, | |
595 | enum zio_checksum child, enum zio_checksum parent); | |
99197f03 JG |
596 | extern enum zio_compress zio_compress_select(spa_t *spa, |
597 | enum zio_compress child, enum zio_compress parent); | |
34dc7c2f | 598 | |
1ce23dca | 599 | extern void zio_cancel(zio_t *zio); |
b128c09f | 600 | extern void zio_suspend(spa_t *spa, zio_t *zio); |
9babb374 | 601 | extern int zio_resume(spa_t *spa); |
b128c09f | 602 | extern void zio_resume_wait(spa_t *spa); |
34dc7c2f BB |
603 | |
604 | /* | |
605 | * Initial setup and teardown. | |
606 | */ | |
607 | extern void zio_init(void); | |
608 | extern void zio_fini(void); | |
609 | ||
610 | /* | |
611 | * Fault injection | |
612 | */ | |
613 | struct zinject_record; | |
614 | extern uint32_t zio_injection_enabled; | |
615 | extern int zio_inject_fault(char *name, int flags, int *id, | |
616 | struct zinject_record *record); | |
617 | extern int zio_inject_list_next(int *id, char *name, size_t buflen, | |
618 | struct zinject_record *record); | |
619 | extern int zio_clear_fault(int id); | |
428870ff | 620 | extern void zio_handle_panic_injection(spa_t *spa, char *tag, uint64_t type); |
34dc7c2f | 621 | extern int zio_handle_fault_injection(zio_t *zio, int error); |
9babb374 | 622 | extern int zio_handle_device_injection(vdev_t *vd, zio_t *zio, int error); |
d977122d DB |
623 | extern int zio_handle_device_injections(vdev_t *vd, zio_t *zio, int err1, |
624 | int err2); | |
b128c09f | 625 | extern int zio_handle_label_injection(zio_t *zio, int error); |
428870ff | 626 | extern void zio_handle_ignored_writes(zio_t *zio); |
26ef0cc7 | 627 | extern hrtime_t zio_handle_io_delay(zio_t *zio); |
428870ff BB |
628 | |
629 | /* | |
630 | * Checksum ereport functions | |
631 | */ | |
b5256303 TC |
632 | extern void zfs_ereport_start_checksum(spa_t *spa, vdev_t *vd, |
633 | zbookmark_phys_t *zb, struct zio *zio, uint64_t offset, uint64_t length, | |
634 | void *arg, struct zio_bad_cksum *info); | |
428870ff | 635 | extern void zfs_ereport_finish_checksum(zio_cksum_report_t *report, |
84c07ada | 636 | const abd_t *good_data, const abd_t *bad_data, boolean_t drop_if_identical); |
428870ff | 637 | |
428870ff BB |
638 | extern void zfs_ereport_free_checksum(zio_cksum_report_t *report); |
639 | ||
640 | /* If we have the good data in hand, this function can be used */ | |
641 | extern void zfs_ereport_post_checksum(spa_t *spa, vdev_t *vd, | |
b5256303 | 642 | zbookmark_phys_t *zb, struct zio *zio, uint64_t offset, uint64_t length, |
84c07ada | 643 | const abd_t *good_data, const abd_t *bad_data, struct zio_bad_cksum *info); |
428870ff BB |
644 | |
645 | /* Called from spa_sync(), but primarily an injection handler */ | |
646 | extern void spa_handle_ignored_writes(spa_t *spa); | |
34dc7c2f | 647 | |
5dbd68a3 | 648 | /* zbookmark_phys functions */ |
fcff0f35 PD |
649 | boolean_t zbookmark_subtree_completed(const struct dnode_phys *dnp, |
650 | const zbookmark_phys_t *subtree_root, const zbookmark_phys_t *last_block); | |
651 | int zbookmark_compare(uint16_t dbss1, uint8_t ibs1, uint16_t dbss2, | |
652 | uint8_t ibs2, const zbookmark_phys_t *zb1, const zbookmark_phys_t *zb2); | |
9ae529ec | 653 | |
34dc7c2f BB |
654 | #ifdef __cplusplus |
655 | } | |
656 | #endif | |
657 | ||
658 | #endif /* _ZIO_H */ |