[mirror_zfs-debian.git] / include / sys / zio.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
 */
/*
 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
 */

#ifndef _ZIO_H
#define	_ZIO_H

#include <sys/zfs_context.h>
#include <sys/spa.h>
#include <sys/txg.h>
#include <sys/avl.h>
#include <sys/fs/zfs.h>
#include <sys/zio_impl.h>

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * Embedded checksum
 */
#define	ZEC_MAGIC	0x210da7ab10c7a11ULL

typedef struct zio_eck {
	uint64_t	zec_magic;	/* for validation, endianness	*/
	zio_cksum_t	zec_cksum;	/* 256-bit checksum		*/
} zio_eck_t;

/*
 * Gang block headers are self-checksumming and contain an array
 * of block pointers.
 */
#define	SPA_GANGBLOCKSIZE	SPA_MINBLOCKSIZE
#define	SPA_GBH_NBLKPTRS	((SPA_GANGBLOCKSIZE - \
	sizeof (zio_eck_t)) / sizeof (blkptr_t))
#define	SPA_GBH_FILLER		((SPA_GANGBLOCKSIZE - \
	sizeof (zio_eck_t) - \
	(SPA_GBH_NBLKPTRS * sizeof (blkptr_t))) /\
	sizeof (uint64_t))

typedef struct zio_gbh {
	blkptr_t		zg_blkptr[SPA_GBH_NBLKPTRS];
	uint64_t		zg_filler[SPA_GBH_FILLER];
	zio_eck_t		zg_tail;
} zio_gbh_phys_t;

enum zio_checksum {
	ZIO_CHECKSUM_INHERIT = 0,
	ZIO_CHECKSUM_ON,
	ZIO_CHECKSUM_OFF,
	ZIO_CHECKSUM_LABEL,
	ZIO_CHECKSUM_GANG_HEADER,
	ZIO_CHECKSUM_ZILOG,
	ZIO_CHECKSUM_FLETCHER_2,
	ZIO_CHECKSUM_FLETCHER_4,
	ZIO_CHECKSUM_SHA256,
	ZIO_CHECKSUM_ZILOG2,
	ZIO_CHECKSUM_FUNCTIONS
};

#define	ZIO_CHECKSUM_ON_VALUE	ZIO_CHECKSUM_FLETCHER_4
#define	ZIO_CHECKSUM_DEFAULT	ZIO_CHECKSUM_ON

#define	ZIO_CHECKSUM_MASK	0xffULL
#define	ZIO_CHECKSUM_VERIFY	(1 << 8)

#define	ZIO_DEDUPCHECKSUM	ZIO_CHECKSUM_SHA256
#define	ZIO_DEDUPDITTO_MIN	100

enum zio_compress {
	ZIO_COMPRESS_INHERIT = 0,
	ZIO_COMPRESS_ON,
	ZIO_COMPRESS_OFF,
	ZIO_COMPRESS_LZJB,
	ZIO_COMPRESS_EMPTY,
	ZIO_COMPRESS_GZIP_1,
	ZIO_COMPRESS_GZIP_2,
	ZIO_COMPRESS_GZIP_3,
	ZIO_COMPRESS_GZIP_4,
	ZIO_COMPRESS_GZIP_5,
	ZIO_COMPRESS_GZIP_6,
	ZIO_COMPRESS_GZIP_7,
	ZIO_COMPRESS_GZIP_8,
	ZIO_COMPRESS_GZIP_9,
	ZIO_COMPRESS_ZLE,
	ZIO_COMPRESS_FUNCTIONS
};

#define	ZIO_COMPRESS_ON_VALUE	ZIO_COMPRESS_LZJB
#define	ZIO_COMPRESS_DEFAULT	ZIO_COMPRESS_OFF

#define	BOOTFS_COMPRESS_VALID(compress)			\
	((compress) == ZIO_COMPRESS_LZJB ||		\
	((compress) == ZIO_COMPRESS_ON &&		\
	ZIO_COMPRESS_ON_VALUE == ZIO_COMPRESS_LZJB) ||	\
	(compress) == ZIO_COMPRESS_OFF)

/*
 * Default Linux timeout for a sd device.
 */
#define ZIO_DELAY_MAX			(30 * MILLISEC)

#define	ZIO_FAILURE_MODE_WAIT		0
#define	ZIO_FAILURE_MODE_CONTINUE	1
#define	ZIO_FAILURE_MODE_PANIC		2

#define	ZIO_PRIORITY_NOW		(zio_priority_table[0])
#define	ZIO_PRIORITY_SYNC_READ		(zio_priority_table[1])
#define	ZIO_PRIORITY_SYNC_WRITE		(zio_priority_table[2])
#define	ZIO_PRIORITY_LOG_WRITE		(zio_priority_table[3])
#define	ZIO_PRIORITY_CACHE_FILL		(zio_priority_table[4])
#define	ZIO_PRIORITY_AGG		(zio_priority_table[5])
#define	ZIO_PRIORITY_FREE		(zio_priority_table[6])
#define	ZIO_PRIORITY_ASYNC_WRITE	(zio_priority_table[7])
#define	ZIO_PRIORITY_ASYNC_READ		(zio_priority_table[8])
#define	ZIO_PRIORITY_RESILVER		(zio_priority_table[9])
#define	ZIO_PRIORITY_SCRUB		(zio_priority_table[10])
#define	ZIO_PRIORITY_DDT_PREFETCH	(zio_priority_table[11])
#define	ZIO_PRIORITY_TABLE_SIZE		12

#define	ZIO_PIPELINE_CONTINUE		0x100
#define	ZIO_PIPELINE_STOP		0x101

enum zio_flag {
	/*
	 * Flags inherited by gang, ddt, and vdev children,
	 * and that must be equal for two zios to aggregate
	 */
	ZIO_FLAG_DONT_AGGREGATE	= 1 << 0,
	ZIO_FLAG_IO_REPAIR	= 1 << 1,
	ZIO_FLAG_SELF_HEAL	= 1 << 2,
	ZIO_FLAG_RESILVER	= 1 << 3,
	ZIO_FLAG_SCRUB		= 1 << 4,
	ZIO_FLAG_SCAN_THREAD	= 1 << 5,

#define	ZIO_FLAG_AGG_INHERIT	(ZIO_FLAG_CANFAIL - 1)

	/*
	 * Flags inherited by ddt, gang, and vdev children.
	 */
	ZIO_FLAG_CANFAIL	= 1 << 6,	/* must be first for INHERIT */
	ZIO_FLAG_SPECULATIVE	= 1 << 7,
	ZIO_FLAG_CONFIG_WRITER	= 1 << 8,
	ZIO_FLAG_DONT_RETRY	= 1 << 9,
	ZIO_FLAG_DONT_CACHE	= 1 << 10,
	ZIO_FLAG_NODATA		= 1 << 11,
	ZIO_FLAG_INDUCE_DAMAGE	= 1 << 12,

#define	ZIO_FLAG_DDT_INHERIT	(ZIO_FLAG_IO_RETRY - 1)
#define	ZIO_FLAG_GANG_INHERIT	(ZIO_FLAG_IO_RETRY - 1)

	/*
	 * Flags inherited by vdev children.
	 */
	ZIO_FLAG_IO_RETRY	= 1 << 13,	/* must be first for INHERIT */
	ZIO_FLAG_PROBE		= 1 << 14,
	ZIO_FLAG_TRYHARD	= 1 << 15,
	ZIO_FLAG_OPTIONAL	= 1 << 16,

#define	ZIO_FLAG_VDEV_INHERIT	(ZIO_FLAG_DONT_QUEUE - 1)

	/*
	 * Flags not inherited by any children.
	 */
	ZIO_FLAG_DONT_QUEUE	= 1 << 17,	/* must be first for INHERIT */
	ZIO_FLAG_DONT_PROPAGATE	= 1 << 18,
	ZIO_FLAG_IO_BYPASS	= 1 << 19,
	ZIO_FLAG_IO_REWRITE	= 1 << 20,
	ZIO_FLAG_RAW		= 1 << 21,
	ZIO_FLAG_GANG_CHILD	= 1 << 22,
	ZIO_FLAG_DDT_CHILD	= 1 << 23,
	ZIO_FLAG_GODFATHER	= 1 << 24
};

#define	ZIO_FLAG_MUSTSUCCEED		0

#define	ZIO_DDT_CHILD_FLAGS(zio)				\
	(((zio)->io_flags & ZIO_FLAG_DDT_INHERIT) |		\
	ZIO_FLAG_DDT_CHILD | ZIO_FLAG_CANFAIL)

#define	ZIO_GANG_CHILD_FLAGS(zio)				\
	(((zio)->io_flags & ZIO_FLAG_GANG_INHERIT) |		\
	ZIO_FLAG_GANG_CHILD | ZIO_FLAG_CANFAIL)

#define	ZIO_VDEV_CHILD_FLAGS(zio)				\
	(((zio)->io_flags & ZIO_FLAG_VDEV_INHERIT) |		\
	ZIO_FLAG_CANFAIL)

enum zio_child {
	ZIO_CHILD_VDEV = 0,
	ZIO_CHILD_GANG,
	ZIO_CHILD_DDT,
	ZIO_CHILD_LOGICAL,
	ZIO_CHILD_TYPES
};

enum zio_wait_type {
	ZIO_WAIT_READY = 0,
	ZIO_WAIT_DONE,
	ZIO_WAIT_TYPES
};

/*
 * We'll take the unused errnos, 'EBADE' and 'EBADR' (from the Convergent
 * graveyard) to indicate checksum errors and fragmentation.
 */
#define	ECKSUM	EBADE
#define	EFRAGS	EBADR

typedef void zio_done_func_t(zio_t *zio);

extern uint8_t zio_priority_table[ZIO_PRIORITY_TABLE_SIZE];
extern char *zio_type_name[ZIO_TYPES];

/*
 * A bookmark is a four-tuple <objset, object, level, blkid> that uniquely
 * identifies any block in the pool.  By convention, the meta-objset (MOS)
 * is objset 0, and the meta-dnode is object 0.  This covers all blocks
 * except root blocks and ZIL blocks, which are defined as follows:
 *
 * Root blocks (objset_phys_t) are object 0, level -1:  <objset, 0, -1, 0>.
 * ZIL blocks are bookmarked <objset, 0, -2, blkid == ZIL sequence number>.
 * dmu_sync()ed ZIL data blocks are bookmarked <objset, object, -2, blkid>.
 *
 * Note: this structure is called a bookmark because its original purpose
 * was to remember where to resume a pool-wide traverse.
 *
 * Note: this structure is passed between userland and the kernel.
 * Therefore it must not change size or alignment between 32/64 bit
 * compilation options.
 */
typedef struct zbookmark {
	uint64_t	zb_objset;
	uint64_t	zb_object;
	int64_t		zb_level;
	uint64_t	zb_blkid;
} zbookmark_t;

#define	SET_BOOKMARK(zb, objset, object, level, blkid)  \
{                                                       \
	(zb)->zb_objset = objset;                       \
	(zb)->zb_object = object;                       \
	(zb)->zb_level = level;                         \
	(zb)->zb_blkid = blkid;                         \
}

#define	ZB_DESTROYED_OBJSET	(-1ULL)

#define	ZB_ROOT_OBJECT		(0ULL)
#define	ZB_ROOT_LEVEL		(-1LL)
#define	ZB_ROOT_BLKID		(0ULL)

#define	ZB_ZIL_OBJECT		(0ULL)
#define	ZB_ZIL_LEVEL		(-2LL)

typedef struct zio_prop {
	enum zio_checksum	zp_checksum;
	enum zio_compress	zp_compress;
	dmu_object_type_t	zp_type;
	uint8_t			zp_level;
	uint8_t			zp_copies;
	uint8_t			zp_dedup;
	uint8_t			zp_dedup_verify;
} zio_prop_t;

typedef struct zio_cksum_report zio_cksum_report_t;

typedef void zio_cksum_finish_f(zio_cksum_report_t *rep,
    const void *good_data);
typedef void zio_cksum_free_f(void *cbdata, size_t size);

struct zio_bad_cksum;				/* defined in zio_checksum.h */

struct zio_cksum_report {
	struct zio_cksum_report *zcr_next;
	nvlist_t		*zcr_ereport;
	nvlist_t		*zcr_detector;
	void			*zcr_cbdata;
	size_t			zcr_cbinfo;	/* passed to zcr_free() */
	uint64_t		zcr_align;
	uint64_t		zcr_length;
	zio_cksum_finish_f	*zcr_finish;
	zio_cksum_free_f	*zcr_free;

	/* internal use only */
	struct zio_bad_cksum	*zcr_ckinfo;	/* information from failure */
};

typedef void zio_vsd_cksum_report_f(zio_t *zio, zio_cksum_report_t *zcr,
    void *arg);

zio_vsd_cksum_report_f	zio_vsd_default_cksum_report;

typedef struct zio_vsd_ops {
	zio_done_func_t		*vsd_free;
	zio_vsd_cksum_report_f	*vsd_cksum_report;
} zio_vsd_ops_t;

typedef struct zio_gang_node {
	zio_gbh_phys_t		*gn_gbh;
	struct zio_gang_node	*gn_child[SPA_GBH_NBLKPTRS];
} zio_gang_node_t;

typedef zio_t *zio_gang_issue_func_t(zio_t *zio, blkptr_t *bp,
    zio_gang_node_t *gn, void *data);

typedef void zio_transform_func_t(zio_t *zio, void *data, uint64_t size);

typedef struct zio_transform {
	void			*zt_orig_data;
	uint64_t		zt_orig_size;
	uint64_t		zt_bufsize;
	zio_transform_func_t	*zt_transform;
	struct zio_transform	*zt_next;
} zio_transform_t;

typedef int zio_pipe_stage_t(zio_t *zio);

/*
 * The io_reexecute flags are distinct from io_flags because the child must
 * be able to propagate them to the parent.  The normal io_flags are local
 * to the zio, not protected by any lock, and not modifiable by children;
 * the reexecute flags are protected by io_lock, modifiable by children,
 * and always propagated -- even when ZIO_FLAG_DONT_PROPAGATE is set.
 */
#define	ZIO_REEXECUTE_NOW	0x01
#define	ZIO_REEXECUTE_SUSPEND	0x02

typedef struct zio_link {
	zio_t		*zl_parent;
	zio_t		*zl_child;
	list_node_t	zl_parent_node;
	list_node_t	zl_child_node;
} zio_link_t;

struct zio {
	/* Core information about this I/O */
	zbookmark_t	io_bookmark;
	zio_prop_t	io_prop;
	zio_type_t	io_type;
	enum zio_child	io_child_type;
	int		io_cmd;
	uint8_t		io_priority;
	uint8_t		io_reexecute;
	uint8_t		io_state[ZIO_WAIT_TYPES];
	uint64_t	io_txg;
	spa_t		*io_spa;
	blkptr_t	*io_bp;
	blkptr_t	*io_bp_override;
	blkptr_t	io_bp_copy;
	list_t		io_parent_list;
	list_t		io_child_list;
	zio_link_t	*io_walk_link;
	zio_t		*io_logical;
	zio_transform_t *io_transform_stack;

	/* Callback info */
	zio_done_func_t	*io_ready;
	zio_done_func_t	*io_done;
	void		*io_private;
	int64_t		io_prev_space_delta;	/* DMU private */
	blkptr_t	io_bp_orig;

	/* Data represented by this I/O */
	void		*io_data;
	void		*io_orig_data;
	uint64_t	io_size;
	uint64_t	io_orig_size;

	/* Stuff for the vdev stack */
	vdev_t		*io_vd;
	void		*io_vsd;
	const zio_vsd_ops_t *io_vsd_ops;

	uint64_t	io_offset;
	uint64_t	io_deadline;
	avl_node_t	io_offset_node;
	avl_node_t	io_deadline_node;
	avl_tree_t	*io_vdev_tree;

	/* Internal pipeline state */
	enum zio_flag	io_flags;
	enum zio_stage	io_stage;
	enum zio_stage	io_pipeline;
	enum zio_flag	io_orig_flags;
	enum zio_stage	io_orig_stage;
	enum zio_stage	io_orig_pipeline;
	uint64_t	io_delay;
	int		io_error;
	int		io_child_error[ZIO_CHILD_TYPES];
	uint64_t	io_children[ZIO_CHILD_TYPES][ZIO_WAIT_TYPES];
	uint64_t	io_child_count;
	uint64_t	io_parent_count;
	uint64_t	*io_stall;
	zio_t		*io_gang_leader;
	zio_gang_node_t	*io_gang_tree;
	void		*io_executor;
	void		*io_waiter;
	kmutex_t	io_lock;
	kcondvar_t	io_cv;

	/* FMA state */
	zio_cksum_report_t *io_cksum_report;
	uint64_t	io_ena;

	/* Taskq dispatching state */
	taskq_ent_t	io_tqent;
};

extern zio_t *zio_null(zio_t *pio, spa_t *spa, vdev_t *vd,
    zio_done_func_t *done, void *private, enum zio_flag flags);

extern zio_t *zio_root(spa_t *spa,
    zio_done_func_t *done, void *private, enum zio_flag flags);

extern zio_t *zio_read(zio_t *pio, spa_t *spa, const blkptr_t *bp, void *data,
    uint64_t size, zio_done_func_t *done, void *private,
    int priority, enum zio_flag flags, const zbookmark_t *zb);

extern zio_t *zio_write(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
    void *data, uint64_t size, const zio_prop_t *zp,
    zio_done_func_t *ready, zio_done_func_t *done, void *private,
    int priority, enum zio_flag flags, const zbookmark_t *zb);

extern zio_t *zio_rewrite(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
    void *data, uint64_t size, zio_done_func_t *done, void *private,
    int priority, enum zio_flag flags, zbookmark_t *zb);

extern void zio_write_override(zio_t *zio, blkptr_t *bp, int copies);

extern void zio_free(spa_t *spa, uint64_t txg, const blkptr_t *bp);

extern zio_t *zio_claim(zio_t *pio, spa_t *spa, uint64_t txg,
    const blkptr_t *bp,
    zio_done_func_t *done, void *private, enum zio_flag flags);

extern zio_t *zio_ioctl(zio_t *pio, spa_t *spa, vdev_t *vd, int cmd,
    zio_done_func_t *done, void *private, int priority, enum zio_flag flags);

extern zio_t *zio_read_phys(zio_t *pio, vdev_t *vd, uint64_t offset,
    uint64_t size, void *data, int checksum,
    zio_done_func_t *done, void *private, int priority, enum zio_flag flags,
    boolean_t labels);

extern zio_t *zio_write_phys(zio_t *pio, vdev_t *vd, uint64_t offset,
    uint64_t size, void *data, int checksum,
    zio_done_func_t *done, void *private, int priority, enum zio_flag flags,
    boolean_t labels);

extern zio_t *zio_free_sync(zio_t *pio, spa_t *spa, uint64_t txg,
    const blkptr_t *bp, enum zio_flag flags);

extern int zio_alloc_zil(spa_t *spa, uint64_t txg, blkptr_t *new_bp,
    blkptr_t *old_bp, uint64_t size, boolean_t use_slog);
extern void zio_free_zil(spa_t *spa, uint64_t txg, blkptr_t *bp);
extern void zio_flush(zio_t *zio, vdev_t *vd);
extern void zio_shrink(zio_t *zio, uint64_t size);

extern int zio_wait(zio_t *zio);
extern void zio_nowait(zio_t *zio);
extern void zio_execute(zio_t *zio);
extern void zio_interrupt(zio_t *zio);

extern zio_t *zio_walk_parents(zio_t *cio);
extern zio_t *zio_walk_children(zio_t *pio);
extern zio_t *zio_unique_parent(zio_t *cio);
extern void zio_add_child(zio_t *pio, zio_t *cio);

extern void *zio_buf_alloc(size_t size);
extern void zio_buf_free(void *buf, size_t size);
extern void *zio_data_buf_alloc(size_t size);
extern void zio_data_buf_free(void *buf, size_t size);

extern void zio_resubmit_stage_async(void *);

extern zio_t *zio_vdev_child_io(zio_t *zio, blkptr_t *bp, vdev_t *vd,
    uint64_t offset, void *data, uint64_t size, int type, int priority,
    enum zio_flag flags, zio_done_func_t *done, void *private);

extern zio_t *zio_vdev_delegated_io(vdev_t *vd, uint64_t offset,
    void *data, uint64_t size, int type, int priority,
    enum zio_flag flags, zio_done_func_t *done, void *private);

extern void zio_vdev_io_bypass(zio_t *zio);
extern void zio_vdev_io_reissue(zio_t *zio);
extern void zio_vdev_io_redone(zio_t *zio);

extern void zio_checksum_verified(zio_t *zio);
extern int zio_worst_error(int e1, int e2);

extern enum zio_checksum zio_checksum_select(enum zio_checksum child,
    enum zio_checksum parent);
extern enum zio_checksum zio_checksum_dedup_select(spa_t *spa,
    enum zio_checksum child, enum zio_checksum parent);
extern enum zio_compress zio_compress_select(enum zio_compress child,
    enum zio_compress parent);

extern void zio_suspend(spa_t *spa, zio_t *zio);
extern int zio_resume(spa_t *spa);
extern void zio_resume_wait(spa_t *spa);

/*
 * Initial setup and teardown.
 */
extern void zio_init(void);
extern void zio_fini(void);

/*
 * Fault injection
 */
struct zinject_record;
extern uint32_t zio_injection_enabled;
extern int zio_inject_fault(char *name, int flags, int *id,
    struct zinject_record *record);
extern int zio_inject_list_next(int *id, char *name, size_t buflen,
    struct zinject_record *record);
extern int zio_clear_fault(int id);
extern void zio_handle_panic_injection(spa_t *spa, char *tag, uint64_t type);
extern int zio_handle_fault_injection(zio_t *zio, int error);
extern int zio_handle_device_injection(vdev_t *vd, zio_t *zio, int error);
extern int zio_handle_label_injection(zio_t *zio, int error);
extern void zio_handle_ignored_writes(zio_t *zio);

/*
 * Checksum ereport functions
 */
extern void zfs_ereport_start_checksum(spa_t *spa, vdev_t *vd, struct zio *zio,
    uint64_t offset, uint64_t length, void *arg, struct zio_bad_cksum *info);
extern void zfs_ereport_finish_checksum(zio_cksum_report_t *report,
    const void *good_data, const void *bad_data, boolean_t drop_if_identical);

extern void zfs_ereport_send_interim_checksum(zio_cksum_report_t *report);
extern void zfs_ereport_free_checksum(zio_cksum_report_t *report);

/* If we have the good data in hand, this function can be used */
extern void zfs_ereport_post_checksum(spa_t *spa, vdev_t *vd,
    struct zio *zio, uint64_t offset, uint64_t length,
    const void *good_data, const void *bad_data, struct zio_bad_cksum *info);

/* Called from spa_sync(), but primarily an injection handler */
extern void spa_handle_ignored_writes(spa_t *spa);

#ifdef	__cplusplus
}
#endif

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