]>
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. |
9ae529ec | 25 | * Copyright (c) 2012 by Delphix. All rights reserved. |
9759c60f | 26 | * Copyright (c) 2013 by Saso Kiselkov. All rights reserved. |
a38718a6 | 27 | */ |
34dc7c2f BB |
28 | |
29 | #ifndef _ZIO_H | |
30 | #define _ZIO_H | |
31 | ||
34dc7c2f BB |
32 | #include <sys/zfs_context.h> |
33 | #include <sys/spa.h> | |
34 | #include <sys/txg.h> | |
35 | #include <sys/avl.h> | |
34dc7c2f BB |
36 | #include <sys/fs/zfs.h> |
37 | #include <sys/zio_impl.h> | |
38 | ||
39 | #ifdef __cplusplus | |
40 | extern "C" { | |
41 | #endif | |
42 | ||
428870ff BB |
43 | /* |
44 | * Embedded checksum | |
45 | */ | |
46 | #define ZEC_MAGIC 0x210da7ab10c7a11ULL | |
34dc7c2f | 47 | |
428870ff BB |
48 | typedef struct zio_eck { |
49 | uint64_t zec_magic; /* for validation, endianness */ | |
50 | zio_cksum_t zec_cksum; /* 256-bit checksum */ | |
51 | } zio_eck_t; | |
34dc7c2f BB |
52 | |
53 | /* | |
54 | * Gang block headers are self-checksumming and contain an array | |
55 | * of block pointers. | |
56 | */ | |
57 | #define SPA_GANGBLOCKSIZE SPA_MINBLOCKSIZE | |
58 | #define SPA_GBH_NBLKPTRS ((SPA_GANGBLOCKSIZE - \ | |
428870ff | 59 | sizeof (zio_eck_t)) / sizeof (blkptr_t)) |
34dc7c2f | 60 | #define SPA_GBH_FILLER ((SPA_GANGBLOCKSIZE - \ |
428870ff | 61 | sizeof (zio_eck_t) - \ |
34dc7c2f BB |
62 | (SPA_GBH_NBLKPTRS * sizeof (blkptr_t))) /\ |
63 | sizeof (uint64_t)) | |
64 | ||
34dc7c2f BB |
65 | typedef struct zio_gbh { |
66 | blkptr_t zg_blkptr[SPA_GBH_NBLKPTRS]; | |
67 | uint64_t zg_filler[SPA_GBH_FILLER]; | |
428870ff | 68 | zio_eck_t zg_tail; |
34dc7c2f BB |
69 | } zio_gbh_phys_t; |
70 | ||
71 | enum zio_checksum { | |
72 | ZIO_CHECKSUM_INHERIT = 0, | |
73 | ZIO_CHECKSUM_ON, | |
74 | ZIO_CHECKSUM_OFF, | |
75 | ZIO_CHECKSUM_LABEL, | |
76 | ZIO_CHECKSUM_GANG_HEADER, | |
77 | ZIO_CHECKSUM_ZILOG, | |
78 | ZIO_CHECKSUM_FLETCHER_2, | |
79 | ZIO_CHECKSUM_FLETCHER_4, | |
80 | ZIO_CHECKSUM_SHA256, | |
428870ff | 81 | ZIO_CHECKSUM_ZILOG2, |
34dc7c2f BB |
82 | ZIO_CHECKSUM_FUNCTIONS |
83 | }; | |
84 | ||
9babb374 | 85 | #define ZIO_CHECKSUM_ON_VALUE ZIO_CHECKSUM_FLETCHER_4 |
34dc7c2f BB |
86 | #define ZIO_CHECKSUM_DEFAULT ZIO_CHECKSUM_ON |
87 | ||
428870ff BB |
88 | #define ZIO_CHECKSUM_MASK 0xffULL |
89 | #define ZIO_CHECKSUM_VERIFY (1 << 8) | |
90 | ||
91 | #define ZIO_DEDUPCHECKSUM ZIO_CHECKSUM_SHA256 | |
92 | #define ZIO_DEDUPDITTO_MIN 100 | |
93 | ||
34dc7c2f BB |
94 | enum zio_compress { |
95 | ZIO_COMPRESS_INHERIT = 0, | |
96 | ZIO_COMPRESS_ON, | |
97 | ZIO_COMPRESS_OFF, | |
98 | ZIO_COMPRESS_LZJB, | |
99 | ZIO_COMPRESS_EMPTY, | |
100 | ZIO_COMPRESS_GZIP_1, | |
101 | ZIO_COMPRESS_GZIP_2, | |
102 | ZIO_COMPRESS_GZIP_3, | |
103 | ZIO_COMPRESS_GZIP_4, | |
104 | ZIO_COMPRESS_GZIP_5, | |
105 | ZIO_COMPRESS_GZIP_6, | |
106 | ZIO_COMPRESS_GZIP_7, | |
107 | ZIO_COMPRESS_GZIP_8, | |
108 | ZIO_COMPRESS_GZIP_9, | |
428870ff | 109 | ZIO_COMPRESS_ZLE, |
9759c60f | 110 | ZIO_COMPRESS_LZ4, |
34dc7c2f BB |
111 | ZIO_COMPRESS_FUNCTIONS |
112 | }; | |
113 | ||
114 | #define ZIO_COMPRESS_ON_VALUE ZIO_COMPRESS_LZJB | |
115 | #define ZIO_COMPRESS_DEFAULT ZIO_COMPRESS_OFF | |
116 | ||
428870ff BB |
117 | #define BOOTFS_COMPRESS_VALID(compress) \ |
118 | ((compress) == ZIO_COMPRESS_LZJB || \ | |
9759c60f | 119 | (compress) == ZIO_COMPRESS_LZ4 || \ |
428870ff BB |
120 | ((compress) == ZIO_COMPRESS_ON && \ |
121 | ZIO_COMPRESS_ON_VALUE == ZIO_COMPRESS_LZJB) || \ | |
122 | (compress) == ZIO_COMPRESS_OFF) | |
123 | ||
a69052be BB |
124 | /* |
125 | * Default Linux timeout for a sd device. | |
126 | */ | |
127 | #define ZIO_DELAY_MAX (30 * MILLISEC) | |
128 | ||
34dc7c2f BB |
129 | #define ZIO_FAILURE_MODE_WAIT 0 |
130 | #define ZIO_FAILURE_MODE_CONTINUE 1 | |
131 | #define ZIO_FAILURE_MODE_PANIC 2 | |
132 | ||
133 | #define ZIO_PRIORITY_NOW (zio_priority_table[0]) | |
134 | #define ZIO_PRIORITY_SYNC_READ (zio_priority_table[1]) | |
135 | #define ZIO_PRIORITY_SYNC_WRITE (zio_priority_table[2]) | |
428870ff BB |
136 | #define ZIO_PRIORITY_LOG_WRITE (zio_priority_table[3]) |
137 | #define ZIO_PRIORITY_CACHE_FILL (zio_priority_table[4]) | |
138 | #define ZIO_PRIORITY_AGG (zio_priority_table[5]) | |
139 | #define ZIO_PRIORITY_FREE (zio_priority_table[6]) | |
140 | #define ZIO_PRIORITY_ASYNC_WRITE (zio_priority_table[7]) | |
141 | #define ZIO_PRIORITY_ASYNC_READ (zio_priority_table[8]) | |
142 | #define ZIO_PRIORITY_RESILVER (zio_priority_table[9]) | |
143 | #define ZIO_PRIORITY_SCRUB (zio_priority_table[10]) | |
144 | #define ZIO_PRIORITY_DDT_PREFETCH (zio_priority_table[11]) | |
145 | #define ZIO_PRIORITY_TABLE_SIZE 12 | |
fb5f0bc8 | 146 | |
34dc7c2f BB |
147 | #define ZIO_PIPELINE_CONTINUE 0x100 |
148 | #define ZIO_PIPELINE_STOP 0x101 | |
149 | ||
428870ff BB |
150 | enum zio_flag { |
151 | /* | |
152 | * Flags inherited by gang, ddt, and vdev children, | |
153 | * and that must be equal for two zios to aggregate | |
154 | */ | |
155 | ZIO_FLAG_DONT_AGGREGATE = 1 << 0, | |
156 | ZIO_FLAG_IO_REPAIR = 1 << 1, | |
157 | ZIO_FLAG_SELF_HEAL = 1 << 2, | |
158 | ZIO_FLAG_RESILVER = 1 << 3, | |
159 | ZIO_FLAG_SCRUB = 1 << 4, | |
572e2857 | 160 | ZIO_FLAG_SCAN_THREAD = 1 << 5, |
428870ff BB |
161 | |
162 | #define ZIO_FLAG_AGG_INHERIT (ZIO_FLAG_CANFAIL - 1) | |
163 | ||
164 | /* | |
165 | * Flags inherited by ddt, gang, and vdev children. | |
166 | */ | |
167 | ZIO_FLAG_CANFAIL = 1 << 6, /* must be first for INHERIT */ | |
168 | ZIO_FLAG_SPECULATIVE = 1 << 7, | |
169 | ZIO_FLAG_CONFIG_WRITER = 1 << 8, | |
170 | ZIO_FLAG_DONT_RETRY = 1 << 9, | |
171 | ZIO_FLAG_DONT_CACHE = 1 << 10, | |
172 | ZIO_FLAG_NODATA = 1 << 11, | |
173 | ZIO_FLAG_INDUCE_DAMAGE = 1 << 12, | |
174 | ||
175 | #define ZIO_FLAG_DDT_INHERIT (ZIO_FLAG_IO_RETRY - 1) | |
176 | #define ZIO_FLAG_GANG_INHERIT (ZIO_FLAG_IO_RETRY - 1) | |
177 | ||
178 | /* | |
179 | * Flags inherited by vdev children. | |
180 | */ | |
181 | ZIO_FLAG_IO_RETRY = 1 << 13, /* must be first for INHERIT */ | |
182 | ZIO_FLAG_PROBE = 1 << 14, | |
183 | ZIO_FLAG_TRYHARD = 1 << 15, | |
184 | ZIO_FLAG_OPTIONAL = 1 << 16, | |
185 | ||
186 | #define ZIO_FLAG_VDEV_INHERIT (ZIO_FLAG_DONT_QUEUE - 1) | |
187 | ||
188 | /* | |
189 | * Flags not inherited by any children. | |
190 | */ | |
191 | ZIO_FLAG_DONT_QUEUE = 1 << 17, /* must be first for INHERIT */ | |
192 | ZIO_FLAG_DONT_PROPAGATE = 1 << 18, | |
193 | ZIO_FLAG_IO_BYPASS = 1 << 19, | |
194 | ZIO_FLAG_IO_REWRITE = 1 << 20, | |
195 | ZIO_FLAG_RAW = 1 << 21, | |
196 | ZIO_FLAG_GANG_CHILD = 1 << 22, | |
197 | ZIO_FLAG_DDT_CHILD = 1 << 23, | |
920dd524 ED |
198 | ZIO_FLAG_GODFATHER = 1 << 24, |
199 | ZIO_FLAG_FASTWRITE = 1 << 25 | |
428870ff BB |
200 | }; |
201 | ||
202 | #define ZIO_FLAG_MUSTSUCCEED 0 | |
203 | ||
204 | #define ZIO_DDT_CHILD_FLAGS(zio) \ | |
205 | (((zio)->io_flags & ZIO_FLAG_DDT_INHERIT) | \ | |
206 | ZIO_FLAG_DDT_CHILD | ZIO_FLAG_CANFAIL) | |
207 | ||
b128c09f BB |
208 | #define ZIO_GANG_CHILD_FLAGS(zio) \ |
209 | (((zio)->io_flags & ZIO_FLAG_GANG_INHERIT) | \ | |
210 | ZIO_FLAG_GANG_CHILD | ZIO_FLAG_CANFAIL) | |
211 | ||
428870ff BB |
212 | #define ZIO_VDEV_CHILD_FLAGS(zio) \ |
213 | (((zio)->io_flags & ZIO_FLAG_VDEV_INHERIT) | \ | |
214 | ZIO_FLAG_CANFAIL) | |
215 | ||
b128c09f BB |
216 | enum zio_child { |
217 | ZIO_CHILD_VDEV = 0, | |
218 | ZIO_CHILD_GANG, | |
428870ff | 219 | ZIO_CHILD_DDT, |
b128c09f BB |
220 | ZIO_CHILD_LOGICAL, |
221 | ZIO_CHILD_TYPES | |
222 | }; | |
223 | ||
224 | enum zio_wait_type { | |
225 | ZIO_WAIT_READY = 0, | |
226 | ZIO_WAIT_DONE, | |
227 | ZIO_WAIT_TYPES | |
228 | }; | |
229 | ||
34dc7c2f BB |
230 | /* |
231 | * We'll take the unused errnos, 'EBADE' and 'EBADR' (from the Convergent | |
232 | * graveyard) to indicate checksum errors and fragmentation. | |
233 | */ | |
234 | #define ECKSUM EBADE | |
235 | #define EFRAGS EBADR | |
236 | ||
34dc7c2f BB |
237 | typedef void zio_done_func_t(zio_t *zio); |
238 | ||
239 | extern uint8_t zio_priority_table[ZIO_PRIORITY_TABLE_SIZE]; | |
240 | extern char *zio_type_name[ZIO_TYPES]; | |
241 | ||
242 | /* | |
243 | * A bookmark is a four-tuple <objset, object, level, blkid> that uniquely | |
244 | * identifies any block in the pool. By convention, the meta-objset (MOS) | |
428870ff BB |
245 | * is objset 0, and the meta-dnode is object 0. This covers all blocks |
246 | * except root blocks and ZIL blocks, which are defined as follows: | |
34dc7c2f | 247 | * |
428870ff BB |
248 | * Root blocks (objset_phys_t) are object 0, level -1: <objset, 0, -1, 0>. |
249 | * ZIL blocks are bookmarked <objset, 0, -2, blkid == ZIL sequence number>. | |
250 | * dmu_sync()ed ZIL data blocks are bookmarked <objset, object, -2, blkid>. | |
34dc7c2f | 251 | * |
428870ff BB |
252 | * Note: this structure is called a bookmark because its original purpose |
253 | * was to remember where to resume a pool-wide traverse. | |
34dc7c2f BB |
254 | * |
255 | * Note: this structure is passed between userland and the kernel. | |
256 | * Therefore it must not change size or alignment between 32/64 bit | |
257 | * compilation options. | |
258 | */ | |
259 | typedef struct zbookmark { | |
260 | uint64_t zb_objset; | |
261 | uint64_t zb_object; | |
262 | int64_t zb_level; | |
263 | uint64_t zb_blkid; | |
264 | } zbookmark_t; | |
265 | ||
428870ff BB |
266 | #define SET_BOOKMARK(zb, objset, object, level, blkid) \ |
267 | { \ | |
268 | (zb)->zb_objset = objset; \ | |
269 | (zb)->zb_object = object; \ | |
270 | (zb)->zb_level = level; \ | |
271 | (zb)->zb_blkid = blkid; \ | |
272 | } | |
273 | ||
274 | #define ZB_DESTROYED_OBJSET (-1ULL) | |
275 | ||
276 | #define ZB_ROOT_OBJECT (0ULL) | |
277 | #define ZB_ROOT_LEVEL (-1LL) | |
278 | #define ZB_ROOT_BLKID (0ULL) | |
279 | ||
280 | #define ZB_ZIL_OBJECT (0ULL) | |
281 | #define ZB_ZIL_LEVEL (-2LL) | |
282 | ||
9ae529ec CS |
283 | #define ZB_IS_ZERO(zb) \ |
284 | ((zb)->zb_objset == 0 && (zb)->zb_object == 0 && \ | |
285 | (zb)->zb_level == 0 && (zb)->zb_blkid == 0) | |
286 | #define ZB_IS_ROOT(zb) \ | |
287 | ((zb)->zb_object == ZB_ROOT_OBJECT && \ | |
288 | (zb)->zb_level == ZB_ROOT_LEVEL && \ | |
289 | (zb)->zb_blkid == ZB_ROOT_BLKID) | |
290 | ||
b128c09f BB |
291 | typedef struct zio_prop { |
292 | enum zio_checksum zp_checksum; | |
293 | enum zio_compress zp_compress; | |
294 | dmu_object_type_t zp_type; | |
295 | uint8_t zp_level; | |
428870ff BB |
296 | uint8_t zp_copies; |
297 | uint8_t zp_dedup; | |
298 | uint8_t zp_dedup_verify; | |
b128c09f BB |
299 | } zio_prop_t; |
300 | ||
428870ff BB |
301 | typedef struct zio_cksum_report zio_cksum_report_t; |
302 | ||
303 | typedef void zio_cksum_finish_f(zio_cksum_report_t *rep, | |
304 | const void *good_data); | |
305 | typedef void zio_cksum_free_f(void *cbdata, size_t size); | |
306 | ||
307 | struct zio_bad_cksum; /* defined in zio_checksum.h */ | |
9ae529ec | 308 | struct dnode_phys; |
428870ff BB |
309 | |
310 | struct zio_cksum_report { | |
311 | struct zio_cksum_report *zcr_next; | |
312 | nvlist_t *zcr_ereport; | |
313 | nvlist_t *zcr_detector; | |
314 | void *zcr_cbdata; | |
315 | size_t zcr_cbinfo; /* passed to zcr_free() */ | |
316 | uint64_t zcr_align; | |
317 | uint64_t zcr_length; | |
318 | zio_cksum_finish_f *zcr_finish; | |
319 | zio_cksum_free_f *zcr_free; | |
320 | ||
321 | /* internal use only */ | |
322 | struct zio_bad_cksum *zcr_ckinfo; /* information from failure */ | |
323 | }; | |
324 | ||
325 | typedef void zio_vsd_cksum_report_f(zio_t *zio, zio_cksum_report_t *zcr, | |
326 | void *arg); | |
327 | ||
328 | zio_vsd_cksum_report_f zio_vsd_default_cksum_report; | |
329 | ||
330 | typedef struct zio_vsd_ops { | |
331 | zio_done_func_t *vsd_free; | |
332 | zio_vsd_cksum_report_f *vsd_cksum_report; | |
333 | } zio_vsd_ops_t; | |
334 | ||
b128c09f BB |
335 | typedef struct zio_gang_node { |
336 | zio_gbh_phys_t *gn_gbh; | |
337 | struct zio_gang_node *gn_child[SPA_GBH_NBLKPTRS]; | |
338 | } zio_gang_node_t; | |
339 | ||
340 | typedef zio_t *zio_gang_issue_func_t(zio_t *zio, blkptr_t *bp, | |
341 | zio_gang_node_t *gn, void *data); | |
342 | ||
343 | typedef void zio_transform_func_t(zio_t *zio, void *data, uint64_t size); | |
344 | ||
345 | typedef struct zio_transform { | |
346 | void *zt_orig_data; | |
347 | uint64_t zt_orig_size; | |
348 | uint64_t zt_bufsize; | |
349 | zio_transform_func_t *zt_transform; | |
350 | struct zio_transform *zt_next; | |
351 | } zio_transform_t; | |
352 | ||
353 | typedef int zio_pipe_stage_t(zio_t *zio); | |
354 | ||
355 | /* | |
356 | * The io_reexecute flags are distinct from io_flags because the child must | |
357 | * be able to propagate them to the parent. The normal io_flags are local | |
358 | * to the zio, not protected by any lock, and not modifiable by children; | |
359 | * the reexecute flags are protected by io_lock, modifiable by children, | |
360 | * and always propagated -- even when ZIO_FLAG_DONT_PROPAGATE is set. | |
361 | */ | |
362 | #define ZIO_REEXECUTE_NOW 0x01 | |
363 | #define ZIO_REEXECUTE_SUSPEND 0x02 | |
364 | ||
d164b209 BB |
365 | typedef struct zio_link { |
366 | zio_t *zl_parent; | |
367 | zio_t *zl_child; | |
368 | list_node_t zl_parent_node; | |
369 | list_node_t zl_child_node; | |
370 | } zio_link_t; | |
371 | ||
34dc7c2f BB |
372 | struct zio { |
373 | /* Core information about this I/O */ | |
34dc7c2f | 374 | zbookmark_t io_bookmark; |
b128c09f BB |
375 | zio_prop_t io_prop; |
376 | zio_type_t io_type; | |
377 | enum zio_child io_child_type; | |
378 | int io_cmd; | |
379 | uint8_t io_priority; | |
380 | uint8_t io_reexecute; | |
d164b209 | 381 | uint8_t io_state[ZIO_WAIT_TYPES]; |
34dc7c2f | 382 | uint64_t io_txg; |
b128c09f | 383 | spa_t *io_spa; |
34dc7c2f | 384 | blkptr_t *io_bp; |
428870ff | 385 | blkptr_t *io_bp_override; |
34dc7c2f | 386 | blkptr_t io_bp_copy; |
d164b209 BB |
387 | list_t io_parent_list; |
388 | list_t io_child_list; | |
389 | zio_link_t *io_walk_link; | |
34dc7c2f | 390 | zio_t *io_logical; |
b128c09f | 391 | zio_transform_t *io_transform_stack; |
34dc7c2f BB |
392 | |
393 | /* Callback info */ | |
394 | zio_done_func_t *io_ready; | |
395 | zio_done_func_t *io_done; | |
396 | void *io_private; | |
428870ff | 397 | int64_t io_prev_space_delta; /* DMU private */ |
34dc7c2f BB |
398 | blkptr_t io_bp_orig; |
399 | ||
400 | /* Data represented by this I/O */ | |
401 | void *io_data; | |
428870ff | 402 | void *io_orig_data; |
34dc7c2f | 403 | uint64_t io_size; |
428870ff | 404 | uint64_t io_orig_size; |
34dc7c2f BB |
405 | |
406 | /* Stuff for the vdev stack */ | |
407 | vdev_t *io_vd; | |
408 | void *io_vsd; | |
428870ff BB |
409 | const zio_vsd_ops_t *io_vsd_ops; |
410 | ||
34dc7c2f | 411 | uint64_t io_offset; |
c06d4368 AX |
412 | uint64_t io_deadline; /* expires at timestamp + deadline */ |
413 | hrtime_t io_timestamp; /* submitted at */ | |
414 | hrtime_t io_delta; /* vdev queue service delta */ | |
415 | uint64_t io_delay; /* vdev disk service delta (ticks) */ | |
34dc7c2f BB |
416 | avl_node_t io_offset_node; |
417 | avl_node_t io_deadline_node; | |
418 | avl_tree_t *io_vdev_tree; | |
34dc7c2f BB |
419 | |
420 | /* Internal pipeline state */ | |
428870ff BB |
421 | enum zio_flag io_flags; |
422 | enum zio_stage io_stage; | |
423 | enum zio_stage io_pipeline; | |
424 | enum zio_flag io_orig_flags; | |
425 | enum zio_stage io_orig_stage; | |
426 | enum zio_stage io_orig_pipeline; | |
b128c09f BB |
427 | int io_error; |
428 | int io_child_error[ZIO_CHILD_TYPES]; | |
429 | uint64_t io_children[ZIO_CHILD_TYPES][ZIO_WAIT_TYPES]; | |
428870ff BB |
430 | uint64_t io_child_count; |
431 | uint64_t io_parent_count; | |
b128c09f | 432 | uint64_t *io_stall; |
9babb374 | 433 | zio_t *io_gang_leader; |
b128c09f BB |
434 | zio_gang_node_t *io_gang_tree; |
435 | void *io_executor; | |
34dc7c2f BB |
436 | void *io_waiter; |
437 | kmutex_t io_lock; | |
438 | kcondvar_t io_cv; | |
439 | ||
440 | /* FMA state */ | |
428870ff | 441 | zio_cksum_report_t *io_cksum_report; |
34dc7c2f | 442 | uint64_t io_ena; |
a38718a6 GA |
443 | |
444 | /* Taskq dispatching state */ | |
445 | taskq_ent_t io_tqent; | |
34dc7c2f BB |
446 | }; |
447 | ||
d164b209 | 448 | extern zio_t *zio_null(zio_t *pio, spa_t *spa, vdev_t *vd, |
428870ff | 449 | zio_done_func_t *done, void *private, enum zio_flag flags); |
34dc7c2f BB |
450 | |
451 | extern zio_t *zio_root(spa_t *spa, | |
428870ff | 452 | zio_done_func_t *done, void *private, enum zio_flag flags); |
34dc7c2f | 453 | |
b128c09f | 454 | extern zio_t *zio_read(zio_t *pio, spa_t *spa, const blkptr_t *bp, void *data, |
34dc7c2f | 455 | uint64_t size, zio_done_func_t *done, void *private, |
428870ff | 456 | int priority, enum zio_flag flags, const zbookmark_t *zb); |
34dc7c2f | 457 | |
b128c09f | 458 | extern zio_t *zio_write(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, |
428870ff | 459 | void *data, uint64_t size, const zio_prop_t *zp, |
b128c09f | 460 | zio_done_func_t *ready, zio_done_func_t *done, void *private, |
428870ff | 461 | int priority, enum zio_flag flags, const zbookmark_t *zb); |
34dc7c2f | 462 | |
b128c09f BB |
463 | extern zio_t *zio_rewrite(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, |
464 | void *data, uint64_t size, zio_done_func_t *done, void *private, | |
428870ff | 465 | int priority, enum zio_flag flags, zbookmark_t *zb); |
b128c09f | 466 | |
428870ff | 467 | extern void zio_write_override(zio_t *zio, blkptr_t *bp, int copies); |
34dc7c2f | 468 | |
428870ff | 469 | extern void zio_free(spa_t *spa, uint64_t txg, const blkptr_t *bp); |
34dc7c2f | 470 | |
428870ff BB |
471 | extern zio_t *zio_claim(zio_t *pio, spa_t *spa, uint64_t txg, |
472 | const blkptr_t *bp, | |
473 | zio_done_func_t *done, void *private, enum zio_flag flags); | |
34dc7c2f BB |
474 | |
475 | extern zio_t *zio_ioctl(zio_t *pio, spa_t *spa, vdev_t *vd, int cmd, | |
428870ff | 476 | zio_done_func_t *done, void *private, int priority, enum zio_flag flags); |
34dc7c2f BB |
477 | |
478 | extern zio_t *zio_read_phys(zio_t *pio, vdev_t *vd, uint64_t offset, | |
479 | uint64_t size, void *data, int checksum, | |
428870ff | 480 | zio_done_func_t *done, void *private, int priority, enum zio_flag flags, |
34dc7c2f BB |
481 | boolean_t labels); |
482 | ||
483 | extern zio_t *zio_write_phys(zio_t *pio, vdev_t *vd, uint64_t offset, | |
484 | uint64_t size, void *data, int checksum, | |
428870ff | 485 | zio_done_func_t *done, void *private, int priority, enum zio_flag flags, |
34dc7c2f BB |
486 | boolean_t labels); |
487 | ||
428870ff BB |
488 | extern zio_t *zio_free_sync(zio_t *pio, spa_t *spa, uint64_t txg, |
489 | const blkptr_t *bp, enum zio_flag flags); | |
490 | ||
491 | extern int zio_alloc_zil(spa_t *spa, uint64_t txg, blkptr_t *new_bp, | |
920dd524 | 492 | uint64_t size, boolean_t use_slog); |
428870ff | 493 | extern void zio_free_zil(spa_t *spa, uint64_t txg, blkptr_t *bp); |
34dc7c2f | 494 | extern void zio_flush(zio_t *zio, vdev_t *vd); |
428870ff | 495 | extern void zio_shrink(zio_t *zio, uint64_t size); |
34dc7c2f BB |
496 | |
497 | extern int zio_wait(zio_t *zio); | |
498 | extern void zio_nowait(zio_t *zio); | |
499 | extern void zio_execute(zio_t *zio); | |
500 | extern void zio_interrupt(zio_t *zio); | |
501 | ||
d164b209 BB |
502 | extern zio_t *zio_walk_parents(zio_t *cio); |
503 | extern zio_t *zio_walk_children(zio_t *pio); | |
504 | extern zio_t *zio_unique_parent(zio_t *cio); | |
505 | extern void zio_add_child(zio_t *pio, zio_t *cio); | |
506 | ||
34dc7c2f BB |
507 | extern void *zio_buf_alloc(size_t size); |
508 | extern void zio_buf_free(void *buf, size_t size); | |
509 | extern void *zio_data_buf_alloc(size_t size); | |
510 | extern void zio_data_buf_free(void *buf, size_t size); | |
86dd0fd9 BB |
511 | extern void *zio_vdev_alloc(void); |
512 | extern void zio_vdev_free(void *buf); | |
34dc7c2f BB |
513 | |
514 | extern void zio_resubmit_stage_async(void *); | |
515 | ||
34dc7c2f BB |
516 | extern zio_t *zio_vdev_child_io(zio_t *zio, blkptr_t *bp, vdev_t *vd, |
517 | uint64_t offset, void *data, uint64_t size, int type, int priority, | |
428870ff | 518 | enum zio_flag flags, zio_done_func_t *done, void *private); |
34dc7c2f | 519 | |
b128c09f BB |
520 | extern zio_t *zio_vdev_delegated_io(vdev_t *vd, uint64_t offset, |
521 | void *data, uint64_t size, int type, int priority, | |
428870ff | 522 | enum zio_flag flags, zio_done_func_t *done, void *private); |
b128c09f | 523 | |
34dc7c2f BB |
524 | extern void zio_vdev_io_bypass(zio_t *zio); |
525 | extern void zio_vdev_io_reissue(zio_t *zio); | |
526 | extern void zio_vdev_io_redone(zio_t *zio); | |
527 | ||
528 | extern void zio_checksum_verified(zio_t *zio); | |
b128c09f | 529 | extern int zio_worst_error(int e1, int e2); |
34dc7c2f | 530 | |
428870ff BB |
531 | extern enum zio_checksum zio_checksum_select(enum zio_checksum child, |
532 | enum zio_checksum parent); | |
533 | extern enum zio_checksum zio_checksum_dedup_select(spa_t *spa, | |
534 | enum zio_checksum child, enum zio_checksum parent); | |
535 | extern enum zio_compress zio_compress_select(enum zio_compress child, | |
536 | enum zio_compress parent); | |
34dc7c2f | 537 | |
b128c09f | 538 | extern void zio_suspend(spa_t *spa, zio_t *zio); |
9babb374 | 539 | extern int zio_resume(spa_t *spa); |
b128c09f | 540 | extern void zio_resume_wait(spa_t *spa); |
34dc7c2f BB |
541 | |
542 | /* | |
543 | * Initial setup and teardown. | |
544 | */ | |
545 | extern void zio_init(void); | |
546 | extern void zio_fini(void); | |
547 | ||
548 | /* | |
549 | * Fault injection | |
550 | */ | |
551 | struct zinject_record; | |
552 | extern uint32_t zio_injection_enabled; | |
553 | extern int zio_inject_fault(char *name, int flags, int *id, | |
554 | struct zinject_record *record); | |
555 | extern int zio_inject_list_next(int *id, char *name, size_t buflen, | |
556 | struct zinject_record *record); | |
557 | extern int zio_clear_fault(int id); | |
428870ff | 558 | extern void zio_handle_panic_injection(spa_t *spa, char *tag, uint64_t type); |
34dc7c2f | 559 | extern int zio_handle_fault_injection(zio_t *zio, int error); |
9babb374 | 560 | extern int zio_handle_device_injection(vdev_t *vd, zio_t *zio, int error); |
b128c09f | 561 | extern int zio_handle_label_injection(zio_t *zio, int error); |
428870ff | 562 | extern void zio_handle_ignored_writes(zio_t *zio); |
c06d4368 | 563 | extern uint64_t zio_handle_io_delay(zio_t *zio); |
428870ff BB |
564 | |
565 | /* | |
566 | * Checksum ereport functions | |
567 | */ | |
568 | extern void zfs_ereport_start_checksum(spa_t *spa, vdev_t *vd, struct zio *zio, | |
569 | uint64_t offset, uint64_t length, void *arg, struct zio_bad_cksum *info); | |
570 | extern void zfs_ereport_finish_checksum(zio_cksum_report_t *report, | |
571 | const void *good_data, const void *bad_data, boolean_t drop_if_identical); | |
572 | ||
573 | extern void zfs_ereport_send_interim_checksum(zio_cksum_report_t *report); | |
574 | extern void zfs_ereport_free_checksum(zio_cksum_report_t *report); | |
575 | ||
576 | /* If we have the good data in hand, this function can be used */ | |
577 | extern void zfs_ereport_post_checksum(spa_t *spa, vdev_t *vd, | |
578 | struct zio *zio, uint64_t offset, uint64_t length, | |
579 | const void *good_data, const void *bad_data, struct zio_bad_cksum *info); | |
580 | ||
581 | /* Called from spa_sync(), but primarily an injection handler */ | |
582 | extern void spa_handle_ignored_writes(spa_t *spa); | |
34dc7c2f | 583 | |
9ae529ec CS |
584 | /* zbookmark functions */ |
585 | boolean_t zbookmark_is_before(const struct dnode_phys *dnp, | |
586 | const zbookmark_t *zb1, const zbookmark_t *zb2); | |
587 | ||
34dc7c2f BB |
588 | #ifdef __cplusplus |
589 | } | |
590 | #endif | |
591 | ||
592 | #endif /* _ZIO_H */ |