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