[mirror_zfs-debian.git] / include / sys / arc.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 (c) 2012, 2016 by Delphix. All rights reserved.
 * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
 */

#ifndef	_SYS_ARC_H
#define	_SYS_ARC_H

#include <sys/zfs_context.h>

#ifdef	__cplusplus
extern "C" {
#endif

#include <sys/zio.h>
#include <sys/dmu.h>
#include <sys/spa.h>
#include <sys/refcount.h>

/*
 * Used by arc_flush() to inform arc_evict_state() that it should evict
 * all available buffers from the arc state being passed in.
 */
#define	ARC_EVICT_ALL	-1ULL

#define	HDR_SET_LSIZE(hdr, x) do { \
	ASSERT(IS_P2ALIGNED(x, 1U << SPA_MINBLOCKSHIFT)); \
	(hdr)->b_lsize = ((x) >> SPA_MINBLOCKSHIFT); \
_NOTE(CONSTCOND) } while (0)

#define	HDR_SET_PSIZE(hdr, x) do { \
	ASSERT(IS_P2ALIGNED((x), 1U << SPA_MINBLOCKSHIFT)); \
	(hdr)->b_psize = ((x) >> SPA_MINBLOCKSHIFT); \
_NOTE(CONSTCOND) } while (0)

#define	HDR_GET_LSIZE(hdr)	((hdr)->b_lsize << SPA_MINBLOCKSHIFT)
#define	HDR_GET_PSIZE(hdr)	((hdr)->b_psize << SPA_MINBLOCKSHIFT)

typedef struct arc_buf_hdr arc_buf_hdr_t;
typedef struct arc_buf arc_buf_t;
typedef struct arc_prune arc_prune_t;
typedef void arc_done_func_t(zio_t *zio, arc_buf_t *buf, void *private);
typedef void arc_prune_func_t(int64_t bytes, void *private);

/* Shared module parameters */
extern int zfs_arc_average_blocksize;

/* generic arc_done_func_t's which you can use */
arc_done_func_t arc_bcopy_func;
arc_done_func_t arc_getbuf_func;

/* generic arc_prune_func_t wrapper for callbacks */
struct arc_prune {
	arc_prune_func_t	*p_pfunc;
	void			*p_private;
	uint64_t		p_adjust;
	list_node_t		p_node;
	refcount_t		p_refcnt;
};

typedef enum arc_strategy {
	ARC_STRATEGY_META_ONLY		= 0, /* Evict only meta data buffers */
	ARC_STRATEGY_META_BALANCED	= 1, /* Evict data buffers if needed */
} arc_strategy_t;

typedef enum arc_flags
{
	/*
	 * Public flags that can be passed into the ARC by external consumers.
	 */
	ARC_FLAG_WAIT			= 1 << 0,	/* perform sync I/O */
	ARC_FLAG_NOWAIT			= 1 << 1,	/* perform async I/O */
	ARC_FLAG_PREFETCH		= 1 << 2,	/* I/O is a prefetch */
	ARC_FLAG_CACHED			= 1 << 3,	/* I/O was in cache */
	ARC_FLAG_L2CACHE		= 1 << 4,	/* cache in L2ARC */
	ARC_FLAG_PREDICTIVE_PREFETCH	= 1 << 5,	/* I/O from zfetch */

	/*
	 * Private ARC flags.  These flags are private ARC only flags that
	 * will show up in b_flags in the arc_hdr_buf_t. These flags should
	 * only be set by ARC code.
	 */
	ARC_FLAG_IN_HASH_TABLE		= 1 << 6,	/* buffer is hashed */
	ARC_FLAG_IO_IN_PROGRESS		= 1 << 7,	/* I/O in progress */
	ARC_FLAG_IO_ERROR		= 1 << 8,	/* I/O failed for buf */
	ARC_FLAG_INDIRECT		= 1 << 9,	/* indirect block */
	/* Indicates that block was read with ASYNC priority. */
	ARC_FLAG_PRIO_ASYNC_READ	= 1 << 10,
	ARC_FLAG_L2_WRITING		= 1 << 11,	/* write in progress */
	ARC_FLAG_L2_EVICTED		= 1 << 12,	/* evicted during I/O */
	ARC_FLAG_L2_WRITE_HEAD		= 1 << 13,	/* head of write list */
	/* indicates that the buffer contains metadata (otherwise, data) */
	ARC_FLAG_BUFC_METADATA		= 1 << 14,

	/* Flags specifying whether optional hdr struct fields are defined */
	ARC_FLAG_HAS_L1HDR		= 1 << 15,
	ARC_FLAG_HAS_L2HDR		= 1 << 16,

	/*
	 * Indicates the arc_buf_hdr_t's b_pdata matches the on-disk data.
	 * This allows the l2arc to use the blkptr's checksum to verify
	 * the data without having to store the checksum in the hdr.
	 */
	ARC_FLAG_COMPRESSED_ARC		= 1 << 17,
	ARC_FLAG_SHARED_DATA		= 1 << 18,

	/*
	 * The arc buffer's compression mode is stored in the top 7 bits of the
	 * flags field, so these dummy flags are included so that MDB can
	 * interpret the enum properly.
	 */
	ARC_FLAG_COMPRESS_0		= 1 << 24,
	ARC_FLAG_COMPRESS_1		= 1 << 25,
	ARC_FLAG_COMPRESS_2		= 1 << 26,
	ARC_FLAG_COMPRESS_3		= 1 << 27,
	ARC_FLAG_COMPRESS_4		= 1 << 28,
	ARC_FLAG_COMPRESS_5		= 1 << 29,
	ARC_FLAG_COMPRESS_6		= 1 << 30

} arc_flags_t;

typedef enum arc_buf_flags {
	ARC_BUF_FLAG_SHARED		= 1 << 0,
	ARC_BUF_FLAG_COMPRESSED		= 1 << 1
} arc_buf_flags_t;

struct arc_buf {
	arc_buf_hdr_t		*b_hdr;
	arc_buf_t		*b_next;
	kmutex_t		b_evict_lock;
	void			*b_data;
	arc_buf_flags_t		b_flags;
};

typedef enum arc_buf_contents {
	ARC_BUFC_INVALID,			/* invalid type */
	ARC_BUFC_DATA,				/* buffer contains data */
	ARC_BUFC_METADATA,			/* buffer contains metadata */
	ARC_BUFC_NUMTYPES
} arc_buf_contents_t;

/*
 * The following breakdows of arc_size exist for kstat only.
 */
typedef enum arc_space_type {
	ARC_SPACE_DATA,
	ARC_SPACE_META,
	ARC_SPACE_HDRS,
	ARC_SPACE_L2HDRS,
	ARC_SPACE_DBUF,
	ARC_SPACE_DNODE,
	ARC_SPACE_BONUS,
	ARC_SPACE_NUMTYPES
} arc_space_type_t;

typedef enum arc_state_type {
	ARC_STATE_ANON,
	ARC_STATE_MRU,
	ARC_STATE_MRU_GHOST,
	ARC_STATE_MFU,
	ARC_STATE_MFU_GHOST,
	ARC_STATE_L2C_ONLY,
	ARC_STATE_NUMTYPES
} arc_state_type_t;

typedef struct arc_buf_info {
	arc_state_type_t	abi_state_type;
	arc_buf_contents_t	abi_state_contents;
	uint32_t		abi_flags;
	uint32_t		abi_bufcnt;
	uint64_t		abi_size;
	uint64_t		abi_spa;
	uint64_t		abi_access;
	uint32_t		abi_mru_hits;
	uint32_t		abi_mru_ghost_hits;
	uint32_t		abi_mfu_hits;
	uint32_t		abi_mfu_ghost_hits;
	uint32_t		abi_l2arc_hits;
	uint32_t		abi_holds;
	uint64_t		abi_l2arc_dattr;
	uint64_t		abi_l2arc_asize;
	enum zio_compress	abi_l2arc_compress;
} arc_buf_info_t;

void arc_space_consume(uint64_t space, arc_space_type_t type);
void arc_space_return(uint64_t space, arc_space_type_t type);
boolean_t arc_is_metadata(arc_buf_t *buf);
enum zio_compress arc_get_compression(arc_buf_t *buf);
int arc_decompress(arc_buf_t *buf);
arc_buf_t *arc_alloc_buf(spa_t *spa, void *tag, arc_buf_contents_t type,
    int32_t size);
arc_buf_t *arc_alloc_compressed_buf(spa_t *spa, void *tag,
    uint64_t psize, uint64_t lsize, enum zio_compress compression_type);
arc_buf_t *arc_loan_buf(spa_t *spa, boolean_t is_metadata, int size);
arc_buf_t *arc_loan_compressed_buf(spa_t *spa, uint64_t psize, uint64_t lsize,
    enum zio_compress compression_type);
void arc_return_buf(arc_buf_t *buf, void *tag);
void arc_loan_inuse_buf(arc_buf_t *buf, void *tag);
void arc_buf_destroy(arc_buf_t *buf, void *tag);
void arc_buf_info(arc_buf_t *buf, arc_buf_info_t *abi, int state_index);
uint64_t arc_buf_size(arc_buf_t *buf);
uint64_t arc_buf_lsize(arc_buf_t *buf);
void arc_buf_access(arc_buf_t *buf);
void arc_release(arc_buf_t *buf, void *tag);
int arc_released(arc_buf_t *buf);
void arc_buf_sigsegv(int sig, siginfo_t *si, void *unused);
void arc_buf_freeze(arc_buf_t *buf);
void arc_buf_thaw(arc_buf_t *buf);
#ifdef ZFS_DEBUG
int arc_referenced(arc_buf_t *buf);
#endif

int arc_read(zio_t *pio, spa_t *spa, const blkptr_t *bp,
    arc_done_func_t *done, void *private, zio_priority_t priority, int flags,
    arc_flags_t *arc_flags, const zbookmark_phys_t *zb);
zio_t *arc_write(zio_t *pio, spa_t *spa, uint64_t txg,
    blkptr_t *bp, arc_buf_t *buf, boolean_t l2arc, const zio_prop_t *zp,
    arc_done_func_t *ready, arc_done_func_t *child_ready,
    arc_done_func_t *physdone, arc_done_func_t *done,
    void *private, zio_priority_t priority, int zio_flags,
    const zbookmark_phys_t *zb);

arc_prune_t *arc_add_prune_callback(arc_prune_func_t *func, void *private);
void arc_remove_prune_callback(arc_prune_t *p);
void arc_freed(spa_t *spa, const blkptr_t *bp);

void arc_flush(spa_t *spa, boolean_t retry);
void arc_tempreserve_clear(uint64_t reserve);
int arc_tempreserve_space(uint64_t reserve, uint64_t txg);

uint64_t arc_target_bytes(void);
void arc_init(void);
void arc_fini(void);

/*
 * Level 2 ARC
 */

void l2arc_add_vdev(spa_t *spa, vdev_t *vd);
void l2arc_remove_vdev(vdev_t *vd);
boolean_t l2arc_vdev_present(vdev_t *vd);
void l2arc_init(void);
void l2arc_fini(void);
void l2arc_start(void);
void l2arc_stop(void);

#ifndef _KERNEL
extern boolean_t arc_watch;
#endif

#ifdef	__cplusplus
}
#endif

#endif /* _SYS_ARC_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	/*
428870ff	22	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
cae5b340	23	* Copyright (c) 2012, 2016 by Delphix. All rights reserved.
c06d4368	24	* Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
34dc7c2f BB	25	*/
	26
	27	#ifndef _SYS_ARC_H
	28	#define _SYS_ARC_H
	29
34dc7c2f BB	30	#include <sys/zfs_context.h>
	31
	32	#ifdef __cplusplus
	33	extern "C" {
	34	#endif
	35
	36	#include <sys/zio.h>
	37	#include <sys/dmu.h>
	38	#include <sys/spa.h>
ab26409d	39	#include <sys/refcount.h>
34dc7c2f	40
e10b0808 AX	41	/*
	42	* Used by arc_flush() to inform arc_evict_state() that it should evict
	43	* all available buffers from the arc state being passed in.
	44	*/
	45	#define ARC_EVICT_ALL -1ULL
	46
cae5b340 AX	47	#define HDR_SET_LSIZE(hdr, x) do { \
	48	ASSERT(IS_P2ALIGNED(x, 1U << SPA_MINBLOCKSHIFT)); \
	49	(hdr)->b_lsize = ((x) >> SPA_MINBLOCKSHIFT); \
	50	_NOTE(CONSTCOND) } while (0)
	51
	52	#define HDR_SET_PSIZE(hdr, x) do { \
	53	ASSERT(IS_P2ALIGNED((x), 1U << SPA_MINBLOCKSHIFT)); \
	54	(hdr)->b_psize = ((x) >> SPA_MINBLOCKSHIFT); \
	55	_NOTE(CONSTCOND) } while (0)
	56
	57	#define HDR_GET_LSIZE(hdr) ((hdr)->b_lsize << SPA_MINBLOCKSHIFT)
	58	#define HDR_GET_PSIZE(hdr) ((hdr)->b_psize << SPA_MINBLOCKSHIFT)
	59
34dc7c2f BB	60	typedef struct arc_buf_hdr arc_buf_hdr_t;
34dc7c2f BB	61	typedef struct arc_buf arc_buf_t;
ab26409d	62	typedef struct arc_prune arc_prune_t;
34dc7c2f	63	typedef void arc_done_func_t(zio_t zio, arc_buf_t buf, void *private);
ab26409d	64	typedef void arc_prune_func_t(int64_t bytes, void *private);
34dc7c2f	65
e10b0808 AX	66	/* Shared module parameters */
	67	extern int zfs_arc_average_blocksize;
	68
34dc7c2f BB	69	/* generic arc_done_func_t's which you can use */
	70	arc_done_func_t arc_bcopy_func;
	71	arc_done_func_t arc_getbuf_func;
	72
ab26409d BB	73	/* generic arc_prune_func_t wrapper for callbacks */
	74	struct arc_prune {
	75	arc_prune_func_t *p_pfunc;
	76	void *p_private;
e10b0808	77	uint64_t p_adjust;
ab26409d BB	78	list_node_t p_node;
	79	refcount_t p_refcnt;
	80	};
	81
e10b0808 AX	82	typedef enum arc_strategy {
	83	ARC_STRATEGY_META_ONLY = 0, /* Evict only meta data buffers */
	84	ARC_STRATEGY_META_BALANCED = 1, /* Evict data buffers if needed */
	85	} arc_strategy_t;
	86
	87	typedef enum arc_flags
	88	{
	89	/*
	90	* Public flags that can be passed into the ARC by external consumers.
	91	*/
cae5b340 AX	92	ARC_FLAG_WAIT = 1 << 0, /* perform sync I/O */
	93	ARC_FLAG_NOWAIT = 1 << 1, /* perform async I/O */
	94	ARC_FLAG_PREFETCH = 1 << 2, /* I/O is a prefetch */
	95	ARC_FLAG_CACHED = 1 << 3, /* I/O was in cache */
	96	ARC_FLAG_L2CACHE = 1 << 4, /* cache in L2ARC */
	97	ARC_FLAG_PREDICTIVE_PREFETCH = 1 << 5, /* I/O from zfetch */
e10b0808 AX	98
	99	/*
	100	* Private ARC flags. These flags are private ARC only flags that
	101	* will show up in b_flags in the arc_hdr_buf_t. These flags should
	102	* only be set by ARC code.
	103	*/
cae5b340 AX	104	ARC_FLAG_IN_HASH_TABLE = 1 << 6, /* buffer is hashed */
	105	ARC_FLAG_IO_IN_PROGRESS = 1 << 7, /* I/O in progress */
	106	ARC_FLAG_IO_ERROR = 1 << 8, /* I/O failed for buf */
	107	ARC_FLAG_INDIRECT = 1 << 9, /* indirect block */
	108	/* Indicates that block was read with ASYNC priority. */
	109	ARC_FLAG_PRIO_ASYNC_READ = 1 << 10,
	110	ARC_FLAG_L2_WRITING = 1 << 11, /* write in progress */
	111	ARC_FLAG_L2_EVICTED = 1 << 12, /* evicted during I/O */
	112	ARC_FLAG_L2_WRITE_HEAD = 1 << 13, /* head of write list */
e10b0808	113	/* indicates that the buffer contains metadata (otherwise, data) */
cae5b340	114	ARC_FLAG_BUFC_METADATA = 1 << 14,
e10b0808 AX	115
e10b0808 AX	116	/* Flags specifying whether optional hdr struct fields are defined */
cae5b340 AX	117	ARC_FLAG_HAS_L1HDR = 1 << 15,
	118	ARC_FLAG_HAS_L2HDR = 1 << 16,
	119
	120	/*
	121	* Indicates the arc_buf_hdr_t's b_pdata matches the on-disk data.
	122	* This allows the l2arc to use the blkptr's checksum to verify
	123	* the data without having to store the checksum in the hdr.
	124	*/
	125	ARC_FLAG_COMPRESSED_ARC = 1 << 17,
	126	ARC_FLAG_SHARED_DATA = 1 << 18,
	127
	128	/*
	129	* The arc buffer's compression mode is stored in the top 7 bits of the
	130	* flags field, so these dummy flags are included so that MDB can
	131	* interpret the enum properly.
	132	*/
	133	ARC_FLAG_COMPRESS_0 = 1 << 24,
	134	ARC_FLAG_COMPRESS_1 = 1 << 25,
	135	ARC_FLAG_COMPRESS_2 = 1 << 26,
	136	ARC_FLAG_COMPRESS_3 = 1 << 27,
	137	ARC_FLAG_COMPRESS_4 = 1 << 28,
	138	ARC_FLAG_COMPRESS_5 = 1 << 29,
	139	ARC_FLAG_COMPRESS_6 = 1 << 30
	140
e10b0808 AX	141	} arc_flags_t;
e10b0808 AX	142
cae5b340 AX	143	typedef enum arc_buf_flags {
	144	ARC_BUF_FLAG_SHARED = 1 << 0,
	145	ARC_BUF_FLAG_COMPRESSED = 1 << 1
	146	} arc_buf_flags_t;
	147
34dc7c2f BB	148	struct arc_buf {
	149	arc_buf_hdr_t *b_hdr;
	150	arc_buf_t *b_next;
428870ff	151	kmutex_t b_evict_lock;
34dc7c2f	152	void *b_data;
cae5b340	153	arc_buf_flags_t b_flags;
34dc7c2f BB	154	};
	155
	156	typedef enum arc_buf_contents {
cae5b340	157	ARC_BUFC_INVALID, /* invalid type */
34dc7c2f BB	158	ARC_BUFC_DATA, /* buffer contains data */
	159	ARC_BUFC_METADATA, /* buffer contains metadata */
	160	ARC_BUFC_NUMTYPES
	161	} arc_buf_contents_t;
34dc7c2f	162
d164b209 BB	163	/*
	164	* The following breakdows of arc_size exist for kstat only.
	165	*/
	166	typedef enum arc_space_type {
	167	ARC_SPACE_DATA,
ea04106b	168	ARC_SPACE_META,
d164b209 BB	169	ARC_SPACE_HDRS,
d164b209 BB	170	ARC_SPACE_L2HDRS,
cae5b340 AX	171	ARC_SPACE_DBUF,
	172	ARC_SPACE_DNODE,
	173	ARC_SPACE_BONUS,
d164b209 BB	174	ARC_SPACE_NUMTYPES
	175	} arc_space_type_t;
	176
a08ee875 LG	177	typedef enum arc_state_type {
	178	ARC_STATE_ANON,
	179	ARC_STATE_MRU,
	180	ARC_STATE_MRU_GHOST,
	181	ARC_STATE_MFU,
	182	ARC_STATE_MFU_GHOST,
	183	ARC_STATE_L2C_ONLY,
	184	ARC_STATE_NUMTYPES
	185	} arc_state_type_t;
	186
	187	typedef struct arc_buf_info {
	188	arc_state_type_t abi_state_type;
	189	arc_buf_contents_t abi_state_contents;
a08ee875	190	uint32_t abi_flags;
cae5b340	191	uint32_t abi_bufcnt;
a08ee875 LG	192	uint64_t abi_size;
	193	uint64_t abi_spa;
	194	uint64_t abi_access;
	195	uint32_t abi_mru_hits;
	196	uint32_t abi_mru_ghost_hits;
	197	uint32_t abi_mfu_hits;
	198	uint32_t abi_mfu_ghost_hits;
	199	uint32_t abi_l2arc_hits;
	200	uint32_t abi_holds;
	201	uint64_t abi_l2arc_dattr;
	202	uint64_t abi_l2arc_asize;
	203	enum zio_compress abi_l2arc_compress;
	204	} arc_buf_info_t;
	205
d164b209 BB	206	void arc_space_consume(uint64_t space, arc_space_type_t type);
d164b209 BB	207	void arc_space_return(uint64_t space, arc_space_type_t type);
cae5b340 AX	208	boolean_t arc_is_metadata(arc_buf_t *buf);
	209	enum zio_compress arc_get_compression(arc_buf_t *buf);
	210	int arc_decompress(arc_buf_t *buf);
	211	arc_buf_t arc_alloc_buf(spa_t spa, void *tag, arc_buf_contents_t type,
	212	int32_t size);
	213	arc_buf_t arc_alloc_compressed_buf(spa_t spa, void *tag,
	214	uint64_t psize, uint64_t lsize, enum zio_compress compression_type);
	215	arc_buf_t arc_loan_buf(spa_t spa, boolean_t is_metadata, int size);
	216	arc_buf_t arc_loan_compressed_buf(spa_t spa, uint64_t psize, uint64_t lsize,
	217	enum zio_compress compression_type);
9babb374	218	void arc_return_buf(arc_buf_t buf, void tag);
428870ff	219	void arc_loan_inuse_buf(arc_buf_t buf, void tag);
cae5b340	220	void arc_buf_destroy(arc_buf_t buf, void tag);
a08ee875	221	void arc_buf_info(arc_buf_t buf, arc_buf_info_t abi, int state_index);
ea04106b	222	uint64_t arc_buf_size(arc_buf_t *buf);
cae5b340	223	uint64_t arc_buf_lsize(arc_buf_t *buf);
047218e2	224	void arc_buf_access(arc_buf_t *buf);
34dc7c2f BB	225	void arc_release(arc_buf_t buf, void tag);
34dc7c2f BB	226	int arc_released(arc_buf_t *buf);
a08ee875	227	void arc_buf_sigsegv(int sig, siginfo_t si, void unused);
34dc7c2f BB	228	void arc_buf_freeze(arc_buf_t *buf);
	229	void arc_buf_thaw(arc_buf_t *buf);
	230	#ifdef ZFS_DEBUG
	231	int arc_referenced(arc_buf_t *buf);
	232	#endif
	233
c06d4368	234	int arc_read(zio_t pio, spa_t spa, const blkptr_t *bp,
a08ee875	235	arc_done_func_t done, void private, zio_priority_t priority, int flags,
e10b0808	236	arc_flags_t arc_flags, const zbookmark_phys_t zb);
428870ff	237	zio_t arc_write(zio_t pio, spa_t *spa, uint64_t txg,
cae5b340 AX	238	blkptr_t bp, arc_buf_t buf, boolean_t l2arc, const zio_prop_t *zp,
	239	arc_done_func_t ready, arc_done_func_t child_ready,
	240	arc_done_func_t physdone, arc_done_func_t done,
	241	void *private, zio_priority_t priority, int zio_flags,
	242	const zbookmark_phys_t *zb);
34dc7c2f	243
ab26409d BB	244	arc_prune_t arc_add_prune_callback(arc_prune_func_t func, void *private);
ab26409d BB	245	void arc_remove_prune_callback(arc_prune_t *p);
c06d4368	246	void arc_freed(spa_t spa, const blkptr_t bp);
ab26409d	247
e10b0808	248	void arc_flush(spa_t *spa, boolean_t retry);
34dc7c2f BB	249	void arc_tempreserve_clear(uint64_t reserve);
	250	int arc_tempreserve_space(uint64_t reserve, uint64_t txg);
	251
8ec27e97	252	uint64_t arc_target_bytes(void);
34dc7c2f BB	253	void arc_init(void);
	254	void arc_fini(void);
	255
	256	/*
	257	* Level 2 ARC
	258	*/
	259
9babb374	260	void l2arc_add_vdev(spa_t spa, vdev_t vd);
34dc7c2f	261	void l2arc_remove_vdev(vdev_t *vd);
b128c09f	262	boolean_t l2arc_vdev_present(vdev_t *vd);
34dc7c2f BB	263	void l2arc_init(void);
34dc7c2f BB	264	void l2arc_fini(void);
b128c09f BB	265	void l2arc_start(void);
b128c09f BB	266	void l2arc_stop(void);
34dc7c2f	267
a08ee875 LG	268	#ifndef _KERNEL
	269	extern boolean_t arc_watch;
	270	#endif
7df05a42	271
34dc7c2f BB	272	#ifdef __cplusplus
	273	}
	274	#endif
	275
	276	#endif /* _SYS_ARC_H */