xref: /illumos-gate/usr/src/uts/common/fs/zfs/sys/zio.h (revision 03361682bf38acf5bcc36ee83a0d6277731eee68)
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 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #ifndef _ZIO_H
28 #define	_ZIO_H
29 
30 #include <sys/zfs_context.h>
31 #include <sys/spa.h>
32 #include <sys/txg.h>
33 #include <sys/avl.h>
34 #include <sys/fs/zfs.h>
35 #include <sys/zio_impl.h>
36 
37 #ifdef	__cplusplus
38 extern "C" {
39 #endif
40 
41 #define	ZBT_MAGIC	0x210da7ab10c7a11ULL	/* zio data bloc tail */
42 
43 typedef struct zio_block_tail {
44 	uint64_t	zbt_magic;	/* for validation, endianness	*/
45 	zio_cksum_t	zbt_cksum;	/* 256-bit checksum		*/
46 } zio_block_tail_t;
47 
48 /*
49  * Gang block headers are self-checksumming and contain an array
50  * of block pointers.
51  */
52 #define	SPA_GANGBLOCKSIZE	SPA_MINBLOCKSIZE
53 #define	SPA_GBH_NBLKPTRS	((SPA_GANGBLOCKSIZE - \
54 	sizeof (zio_block_tail_t)) / sizeof (blkptr_t))
55 #define	SPA_GBH_FILLER		((SPA_GANGBLOCKSIZE - \
56 	sizeof (zio_block_tail_t) - \
57 	(SPA_GBH_NBLKPTRS * sizeof (blkptr_t))) /\
58 	sizeof (uint64_t))
59 
60 typedef struct zio_gbh {
61 	blkptr_t		zg_blkptr[SPA_GBH_NBLKPTRS];
62 	uint64_t		zg_filler[SPA_GBH_FILLER];
63 	zio_block_tail_t	zg_tail;
64 } zio_gbh_phys_t;
65 
66 enum zio_checksum {
67 	ZIO_CHECKSUM_INHERIT = 0,
68 	ZIO_CHECKSUM_ON,
69 	ZIO_CHECKSUM_OFF,
70 	ZIO_CHECKSUM_LABEL,
71 	ZIO_CHECKSUM_GANG_HEADER,
72 	ZIO_CHECKSUM_ZILOG,
73 	ZIO_CHECKSUM_FLETCHER_2,
74 	ZIO_CHECKSUM_FLETCHER_4,
75 	ZIO_CHECKSUM_SHA256,
76 	ZIO_CHECKSUM_FUNCTIONS
77 };
78 
79 #define	ZIO_CHECKSUM_ON_VALUE	ZIO_CHECKSUM_FLETCHER_2
80 #define	ZIO_CHECKSUM_DEFAULT	ZIO_CHECKSUM_ON
81 
82 enum zio_compress {
83 	ZIO_COMPRESS_INHERIT = 0,
84 	ZIO_COMPRESS_ON,
85 	ZIO_COMPRESS_OFF,
86 	ZIO_COMPRESS_LZJB,
87 	ZIO_COMPRESS_EMPTY,
88 	ZIO_COMPRESS_GZIP_1,
89 	ZIO_COMPRESS_GZIP_2,
90 	ZIO_COMPRESS_GZIP_3,
91 	ZIO_COMPRESS_GZIP_4,
92 	ZIO_COMPRESS_GZIP_5,
93 	ZIO_COMPRESS_GZIP_6,
94 	ZIO_COMPRESS_GZIP_7,
95 	ZIO_COMPRESS_GZIP_8,
96 	ZIO_COMPRESS_GZIP_9,
97 	ZIO_COMPRESS_FUNCTIONS
98 };
99 
100 #define	ZIO_COMPRESS_ON_VALUE	ZIO_COMPRESS_LZJB
101 #define	ZIO_COMPRESS_DEFAULT	ZIO_COMPRESS_OFF
102 
103 #define	ZIO_FAILURE_MODE_WAIT		0
104 #define	ZIO_FAILURE_MODE_CONTINUE	1
105 #define	ZIO_FAILURE_MODE_PANIC		2
106 
107 #define	ZIO_PRIORITY_NOW		(zio_priority_table[0])
108 #define	ZIO_PRIORITY_SYNC_READ		(zio_priority_table[1])
109 #define	ZIO_PRIORITY_SYNC_WRITE		(zio_priority_table[2])
110 #define	ZIO_PRIORITY_ASYNC_READ		(zio_priority_table[3])
111 #define	ZIO_PRIORITY_ASYNC_WRITE	(zio_priority_table[4])
112 #define	ZIO_PRIORITY_FREE		(zio_priority_table[5])
113 #define	ZIO_PRIORITY_CACHE_FILL		(zio_priority_table[6])
114 #define	ZIO_PRIORITY_LOG_WRITE		(zio_priority_table[7])
115 #define	ZIO_PRIORITY_RESILVER		(zio_priority_table[8])
116 #define	ZIO_PRIORITY_SCRUB		(zio_priority_table[9])
117 #define	ZIO_PRIORITY_TABLE_SIZE		10
118 
119 #define	ZIO_FLAG_MUSTSUCCEED		0x00000
120 #define	ZIO_FLAG_CANFAIL		0x00001
121 #define	ZIO_FLAG_SPECULATIVE		0x00002
122 #define	ZIO_FLAG_CONFIG_WRITER		0x00004
123 #define	ZIO_FLAG_DONT_RETRY		0x00008
124 
125 #define	ZIO_FLAG_DONT_CACHE		0x00010
126 #define	ZIO_FLAG_DONT_QUEUE		0x00020
127 #define	ZIO_FLAG_DONT_AGGREGATE		0x00040
128 #define	ZIO_FLAG_DONT_PROPAGATE		0x00080
129 
130 #define	ZIO_FLAG_IO_BYPASS		0x00100
131 #define	ZIO_FLAG_IO_REPAIR		0x00200
132 #define	ZIO_FLAG_IO_RETRY		0x00400
133 #define	ZIO_FLAG_IO_REWRITE		0x00800
134 
135 #define	ZIO_FLAG_SELF_HEAL		0x01000
136 #define	ZIO_FLAG_RESILVER		0x02000
137 #define	ZIO_FLAG_SCRUB			0x04000
138 #define	ZIO_FLAG_SCRUB_THREAD		0x08000
139 
140 #define	ZIO_FLAG_PROBE			0x10000
141 #define	ZIO_FLAG_GANG_CHILD		0x20000
142 #define	ZIO_FLAG_RAW			0x40000
143 
144 #define	ZIO_FLAG_GANG_INHERIT		\
145 	(ZIO_FLAG_CANFAIL |		\
146 	ZIO_FLAG_SPECULATIVE |		\
147 	ZIO_FLAG_CONFIG_WRITER |	\
148 	ZIO_FLAG_DONT_RETRY |		\
149 	ZIO_FLAG_DONT_CACHE |		\
150 	ZIO_FLAG_DONT_AGGREGATE |	\
151 	ZIO_FLAG_SELF_HEAL |		\
152 	ZIO_FLAG_RESILVER |		\
153 	ZIO_FLAG_SCRUB |		\
154 	ZIO_FLAG_SCRUB_THREAD)
155 
156 #define	ZIO_FLAG_VDEV_INHERIT		\
157 	(ZIO_FLAG_GANG_INHERIT |	\
158 	ZIO_FLAG_IO_REPAIR |		\
159 	ZIO_FLAG_IO_RETRY |		\
160 	ZIO_FLAG_PROBE)
161 
162 #define	ZIO_FLAG_AGG_INHERIT		\
163 	(ZIO_FLAG_DONT_AGGREGATE |	\
164 	ZIO_FLAG_IO_REPAIR |		\
165 	ZIO_FLAG_SELF_HEAL |		\
166 	ZIO_FLAG_RESILVER |		\
167 	ZIO_FLAG_SCRUB |		\
168 	ZIO_FLAG_SCRUB_THREAD)
169 
170 #define	ZIO_PIPELINE_CONTINUE		0x100
171 #define	ZIO_PIPELINE_STOP		0x101
172 
173 #define	ZIO_GANG_CHILD_FLAGS(zio)				\
174 	(((zio)->io_flags & ZIO_FLAG_GANG_INHERIT) |		\
175 	ZIO_FLAG_GANG_CHILD | ZIO_FLAG_CANFAIL)
176 
177 enum zio_child {
178 	ZIO_CHILD_VDEV = 0,
179 	ZIO_CHILD_GANG,
180 	ZIO_CHILD_LOGICAL,
181 	ZIO_CHILD_TYPES
182 };
183 
184 enum zio_wait_type {
185 	ZIO_WAIT_READY = 0,
186 	ZIO_WAIT_DONE,
187 	ZIO_WAIT_TYPES
188 };
189 
190 /*
191  * We'll take the unused errnos, 'EBADE' and 'EBADR' (from the Convergent
192  * graveyard) to indicate checksum errors and fragmentation.
193  */
194 #define	ECKSUM	EBADE
195 #define	EFRAGS	EBADR
196 
197 typedef struct zio zio_t;
198 typedef void zio_done_func_t(zio_t *zio);
199 
200 extern uint8_t zio_priority_table[ZIO_PRIORITY_TABLE_SIZE];
201 extern char *zio_type_name[ZIO_TYPES];
202 
203 /*
204  * A bookmark is a four-tuple <objset, object, level, blkid> that uniquely
205  * identifies any block in the pool.  By convention, the meta-objset (MOS)
206  * is objset 0, the meta-dnode is object 0, the root block (osphys_t) is
207  * level -1 of the meta-dnode, and intent log blocks (which are chained
208  * off the root block) have blkid == sequence number.  In summary:
209  *
210  *	mos is objset 0
211  *	meta-dnode is object 0
212  *	root block is <objset, 0, -1, 0>
213  *	intent log is <objset, 0, -1, ZIL sequence number>
214  *
215  * Note: this structure is called a bookmark because its first purpose was
216  * to remember where to resume a pool-wide traverse.  The absolute ordering
217  * for block visitation during traversal is defined in compare_bookmark().
218  *
219  * Note: this structure is passed between userland and the kernel.
220  * Therefore it must not change size or alignment between 32/64 bit
221  * compilation options.
222  */
223 typedef struct zbookmark {
224 	uint64_t	zb_objset;
225 	uint64_t	zb_object;
226 	int64_t		zb_level;
227 	uint64_t	zb_blkid;
228 } zbookmark_t;
229 
230 typedef struct zio_prop {
231 	enum zio_checksum	zp_checksum;
232 	enum zio_compress	zp_compress;
233 	dmu_object_type_t	zp_type;
234 	uint8_t			zp_level;
235 	uint8_t			zp_ndvas;
236 } zio_prop_t;
237 
238 typedef struct zio_gang_node {
239 	zio_gbh_phys_t		*gn_gbh;
240 	struct zio_gang_node	*gn_child[SPA_GBH_NBLKPTRS];
241 } zio_gang_node_t;
242 
243 typedef zio_t *zio_gang_issue_func_t(zio_t *zio, blkptr_t *bp,
244     zio_gang_node_t *gn, void *data);
245 
246 typedef void zio_transform_func_t(zio_t *zio, void *data, uint64_t size);
247 
248 typedef struct zio_transform {
249 	void			*zt_orig_data;
250 	uint64_t		zt_orig_size;
251 	uint64_t		zt_bufsize;
252 	zio_transform_func_t	*zt_transform;
253 	struct zio_transform	*zt_next;
254 } zio_transform_t;
255 
256 typedef int zio_pipe_stage_t(zio_t *zio);
257 
258 /*
259  * The io_reexecute flags are distinct from io_flags because the child must
260  * be able to propagate them to the parent.  The normal io_flags are local
261  * to the zio, not protected by any lock, and not modifiable by children;
262  * the reexecute flags are protected by io_lock, modifiable by children,
263  * and always propagated -- even when ZIO_FLAG_DONT_PROPAGATE is set.
264  */
265 #define	ZIO_REEXECUTE_NOW	0x01
266 #define	ZIO_REEXECUTE_SUSPEND	0x02
267 
268 struct zio {
269 	/* Core information about this I/O */
270 	zbookmark_t	io_bookmark;
271 	zio_prop_t	io_prop;
272 	zio_type_t	io_type;
273 	enum zio_child	io_child_type;
274 	int		io_cmd;
275 	uint8_t		io_priority;
276 	uint8_t		io_reexecute;
277 	uint8_t		io_async_root;
278 	uint64_t	io_txg;
279 	spa_t		*io_spa;
280 	blkptr_t	*io_bp;
281 	blkptr_t	io_bp_copy;
282 	zio_t		*io_parent;
283 	zio_t		*io_child;
284 	zio_t		*io_sibling_prev;
285 	zio_t		*io_sibling_next;
286 	zio_t		*io_logical;
287 	zio_transform_t *io_transform_stack;
288 
289 	/* Callback info */
290 	zio_done_func_t	*io_ready;
291 	zio_done_func_t	*io_done;
292 	void		*io_private;
293 	blkptr_t	io_bp_orig;
294 
295 	/* Data represented by this I/O */
296 	void		*io_data;
297 	uint64_t	io_size;
298 
299 	/* Stuff for the vdev stack */
300 	vdev_t		*io_vd;
301 	void		*io_vsd;
302 	zio_done_func_t	*io_vsd_free;
303 	uint64_t	io_offset;
304 	uint64_t	io_deadline;
305 	avl_node_t	io_offset_node;
306 	avl_node_t	io_deadline_node;
307 	avl_tree_t	*io_vdev_tree;
308 	zio_t		*io_delegate_list;
309 	zio_t		*io_delegate_next;
310 
311 	/* Internal pipeline state */
312 	int		io_flags;
313 	zio_stage_t	io_stage;
314 	uint32_t	io_pipeline;
315 	int		io_orig_flags;
316 	zio_stage_t	io_orig_stage;
317 	uint32_t	io_orig_pipeline;
318 	int		io_error;
319 	int		io_child_error[ZIO_CHILD_TYPES];
320 	uint64_t	io_children[ZIO_CHILD_TYPES][ZIO_WAIT_TYPES];
321 	uint64_t	*io_stall;
322 	zio_gang_node_t	*io_gang_tree;
323 	void		*io_executor;
324 	void		*io_waiter;
325 	kmutex_t	io_lock;
326 	kcondvar_t	io_cv;
327 
328 	/* FMA state */
329 	uint64_t	io_ena;
330 };
331 
332 extern zio_t *zio_null(zio_t *pio, spa_t *spa,
333     zio_done_func_t *done, void *private, int flags);
334 
335 extern zio_t *zio_root(spa_t *spa,
336     zio_done_func_t *done, void *private, int flags);
337 
338 extern zio_t *zio_read(zio_t *pio, spa_t *spa, const blkptr_t *bp, void *data,
339     uint64_t size, zio_done_func_t *done, void *private,
340     int priority, int flags, const zbookmark_t *zb);
341 
342 extern zio_t *zio_write(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
343     void *data, uint64_t size, zio_prop_t *zp,
344     zio_done_func_t *ready, zio_done_func_t *done, void *private,
345     int priority, int flags, const zbookmark_t *zb);
346 
347 extern zio_t *zio_rewrite(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
348     void *data, uint64_t size, zio_done_func_t *done, void *private,
349     int priority, int flags, zbookmark_t *zb);
350 
351 extern void zio_skip_write(zio_t *zio);
352 
353 extern zio_t *zio_free(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
354     zio_done_func_t *done, void *private, int flags);
355 
356 extern zio_t *zio_claim(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
357     zio_done_func_t *done, void *private, int flags);
358 
359 extern zio_t *zio_ioctl(zio_t *pio, spa_t *spa, vdev_t *vd, int cmd,
360     zio_done_func_t *done, void *private, int priority, int flags);
361 
362 extern zio_t *zio_read_phys(zio_t *pio, vdev_t *vd, uint64_t offset,
363     uint64_t size, void *data, int checksum,
364     zio_done_func_t *done, void *private, int priority, int flags,
365     boolean_t labels);
366 
367 extern zio_t *zio_write_phys(zio_t *pio, vdev_t *vd, uint64_t offset,
368     uint64_t size, void *data, int checksum,
369     zio_done_func_t *done, void *private, int priority, int flags,
370     boolean_t labels);
371 
372 extern int zio_alloc_blk(spa_t *spa, uint64_t size, blkptr_t *new_bp,
373     blkptr_t *old_bp, uint64_t txg);
374 extern void zio_free_blk(spa_t *spa, blkptr_t *bp, uint64_t txg);
375 extern void zio_flush(zio_t *zio, vdev_t *vd);
376 
377 extern int zio_wait(zio_t *zio);
378 extern void zio_nowait(zio_t *zio);
379 extern void zio_execute(zio_t *zio);
380 extern void zio_interrupt(zio_t *zio);
381 
382 extern void *zio_buf_alloc(size_t size);
383 extern void zio_buf_free(void *buf, size_t size);
384 extern void *zio_data_buf_alloc(size_t size);
385 extern void zio_data_buf_free(void *buf, size_t size);
386 
387 extern void zio_resubmit_stage_async(void *);
388 
389 extern zio_t *zio_vdev_child_io(zio_t *zio, blkptr_t *bp, vdev_t *vd,
390     uint64_t offset, void *data, uint64_t size, int type, int priority,
391     int flags, zio_done_func_t *done, void *private);
392 
393 extern zio_t *zio_vdev_delegated_io(vdev_t *vd, uint64_t offset,
394     void *data, uint64_t size, int type, int priority,
395     int flags, zio_done_func_t *done, void *private);
396 
397 extern void zio_vdev_io_bypass(zio_t *zio);
398 extern void zio_vdev_io_reissue(zio_t *zio);
399 extern void zio_vdev_io_redone(zio_t *zio);
400 
401 extern void zio_checksum_verified(zio_t *zio);
402 extern int zio_worst_error(int e1, int e2);
403 
404 extern uint8_t zio_checksum_select(uint8_t child, uint8_t parent);
405 extern uint8_t zio_compress_select(uint8_t child, uint8_t parent);
406 
407 extern void zio_suspend(spa_t *spa, zio_t *zio);
408 extern void zio_resume(spa_t *spa);
409 extern void zio_resume_wait(spa_t *spa);
410 
411 /*
412  * Initial setup and teardown.
413  */
414 extern void zio_init(void);
415 extern void zio_fini(void);
416 
417 /*
418  * Fault injection
419  */
420 struct zinject_record;
421 extern uint32_t zio_injection_enabled;
422 extern int zio_inject_fault(char *name, int flags, int *id,
423     struct zinject_record *record);
424 extern int zio_inject_list_next(int *id, char *name, size_t buflen,
425     struct zinject_record *record);
426 extern int zio_clear_fault(int id);
427 extern int zio_handle_fault_injection(zio_t *zio, int error);
428 extern int zio_handle_device_injection(vdev_t *vd, int error);
429 extern int zio_handle_label_injection(zio_t *zio, int error);
430 
431 #ifdef	__cplusplus
432 }
433 #endif
434 
435 #endif	/* _ZIO_H */
436