/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_MD_MIRROR_H
#define	_SYS_MD_MIRROR_H

#include <sys/callb.h>
#include <sys/lvm/mdvar.h>
#include <sys/lvm/md_mirror_shared.h>
#include <sys/lvm/md_rename.h>
#ifdef	_KERNEL
#include <sys/sunddi.h>
#endif

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * following bits are used in status word in the common section
 * of unit structure
 */
#define	SMS_IS(sm, state) (((sm)->sm_state & (state)) != 0)
#define	SMS_BY_INDEX_IS(un, index, state) \
		(((un)->un_sm[(index)].sm_state & (state)) != 0)

#define	SMS_BY_INDEX_IS_TARGET(un, index) \
		((un)->un_sm[(index)].sm_flags & MD_SM_RESYNC_TARGET)

#define	SUBMIRROR_IS_READABLE(un, isubmirror)				\
	((((un)->un_sm[(isubmirror)].sm_state & SMS_IGNORE) == 0) &&	\
	    ((un)->un_sm[(isubmirror)].sm_state & 			\
	    (SMS_RUNNING | SMS_COMP_ERRED | SMS_COMP_RESYNC)))

#define	SUBMIRROR_IS_WRITEABLE(un, isubmirror)			\
	((un)->un_sm[(isubmirror)].sm_state &			\
	    (SMS_RUNNING | SMS_COMP_ERRED | SMS_COMP_RESYNC |	\
	    SMS_ATTACHED_RESYNC | SMS_OFFLINE_RESYNC))

/*
 * Default resync block size for MN resync messages
 */
#define	MD_DEF_RESYNC_BLK_SZ		8192

/*
 * macro to test if the current block is within the current resync region
 */
#define	IN_RESYNC_REGION(un, ps) \
	((un->un_rs_prev_overlap != NULL) && (ps->ps_firstblk >= \
	    un->un_rs_prev_overlap->ps_firstblk) && \
	    (ps->ps_lastblk <=  un->un_rs_prev_overlap->ps_lastblk))
/*
 * Default resync update interval (in minutes).
 */
#define	MD_DEF_MIRROR_RESYNC_INTVL	5

/*
 * Defines for flags argument in function set_sm_comp_state()
 */
#define	MD_STATE_NO_XMIT	0x0000 /* Local action, (sent from master) */
#define	MD_STATE_XMIT		0x0001 /* Non-local action, send to master */
#define	MD_STATE_WMUPDATE	0x0002 /* Action because of watermark update */
#define	MD_STATE_OCHELD		0x0004 /* open/close lock held */

/*
 * Defines for flags argument in function check_comp_4_hotspares()
 */
#define	MD_HOTSPARE_NO_XMIT	0x0000 /* Local action, (sent from master) */
#define	MD_HOTSPARE_XMIT	0x0001 /* Non-local action, send to master */
#define	MD_HOTSPARE_WMUPDATE	0x0002 /* Action because of watermark update */
#define	MD_HOTSPARE_LINKHELD	0x0004 /* md_link_rw lock held */

/*
 * Defines for argument in function send_mn_resync_done_message()
 */
#define	RESYNC_ERR		0x1
#define	CLEAR_OPT_NOT_DONE	0x2

/*
 * Defines for argument in function resync_read_blk_range()
 */
#define	MD_FIRST_RESYNC_NEXT	0x1
#define	MD_SEND_MESS_XMIT	0x2
#define	MD_RESYNC_FLAG_ERR	0x4

/*
 * Define for argument in function wait_for_overlaps()
 */
#define	MD_OVERLAP_ALLOW_REPEAT	0x1	/* Allow if ps already in tree */
#define	MD_OVERLAP_NO_REPEAT	0	/* ps must not already be in tree */

/*
 * Define for max retries of mirror_owner
 */
#define	MD_OWNER_RETRIES	10

/*
 * mm_submirror32_od and mm_unit32_od are used only for 32 bit old format
 */
#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
#pragma pack(4)
#endif
typedef struct  mm_submirror32_od {	/* submirrors */
	mdkey_t		sm_key;
	dev32_t		sm_dev;
	sm_state_t	sm_state;
	sm_flags_t	sm_flags;
	caddr32_t	xx_sm_shared_by_blk;	/* really void *) */
	caddr32_t	xx_sm_shared_by_indx;	/* really void *) */
	caddr32_t	xx_sm_get_component_count;
	caddr32_t	xx_sm_get_bcss;	/* block count skip size */
	md_m_shared32_od_t sm_shared;	/* used for mirroring plain devices */
	int		sm_hsp_id;	/* used for mirroring plain devices */
	struct timeval32 sm_timestamp;	/* time of last state change */
} mm_submirror32_od_t;

typedef struct	mm_submirror {		/* submirrors */
	mdkey_t		sm_key;
	md_dev64_t	sm_dev;		/* 64 bit */
	sm_state_t	sm_state;
	sm_flags_t	sm_flags;
	md_m_shared_t	sm_shared;	/* used for mirroring plain devices */
	int		sm_hsp_id;	/* used for mirroring plain devices */
	md_timeval32_t	sm_timestamp;	/* time of last state change, 32 bit */
} mm_submirror_t;

typedef struct mm_unit32_od {
	mdc_unit32_od_t	c;			/* common stuff */

	int		un_last_read;		/* last submirror index read */
	uint_t		un_changecnt;
	ushort_t	un_nsm;			/* number of submirrors */
	mm_submirror32_od_t un_sm[NMIRROR];
	int		un_overlap_tree_flag;
	int		xx_un_overlap_tree_mx[2];	/* replaces mutex */
	ushort_t	xx_un_overlap_tree_cv;
	caddr32_t	xx_un_overlap_root;
	mm_rd_opt_t	un_read_option;		/* mirror read option */
	mm_wr_opt_t	un_write_option;	/* mirror write option */
	mm_pass_num_t	un_pass_num;		/* resync pass number */
	/*
	 * following used to keep dirty bitmaps
	 */
	int		xx_un_resync_mx[2];	/* replaces mutex */
	ushort_t	xx_un_resync_cv;
	uint_t		un_resync_flg;
	uint_t		un_waiting_to_mark;
	uint_t		un_waiting_to_commit;
	caddr32_t	xx_un_outstanding_writes;	/* outstanding write */
	caddr32_t	xx_un_goingclean_bm;
	caddr32_t	xx_un_goingdirty_bm;
	caddr32_t	xx_un_dirty_bm;
	caddr32_t	xx_un_resync_bm;
	uint_t		un_rrd_blksize;	/* The blocksize of the dirty bits */
	uint_t		un_rrd_num;	/* The number of resync regions */
	mddb_recid_t	un_rr_dirty_recid;	/* resync region bm record id */
	/*
	 * following stuff is private to resync process
	 */
	int		un_rs_copysize;
	int		un_rs_dests;	/* destinations */
	daddr32_t	un_rs_resync_done;	/* used for percent done */
	daddr32_t	un_rs_resync_2_do;	/* user for percent done */
	int		un_rs_dropped_lock;
	caddr32_t	un_rs_type;		/* type of resync in progress */
	/*
	 * Incore elements in this old structure are no longer referenced by
	 * current 64 bit kernel.  Comment them out for maintenance purpose.
	 *
	 * 	mm_submirror_ic_t	un_smic[NMIRROR];
	 * 	kmutex_t		un_ovrlap_chn_mx;
	 * 	kcondvar_t		un_ovrlap_chn_cv;
	 * 	struct md_mps		*un_ovrlap_chn;
	 * 	kmutex_t		un_resync_mx;
	 * 	kcondvar_t		un_resync_cv;
	 * 	short			*un_outstanding_writes;
	 * 	uchar_t			*un_goingclean_bm;
	 * 	uchar_t			*un_goingdirty_bm;
	 * 	uchar_t			*un_dirty_bm;
	 * 	uchar_t			*un_resync_bm;
	 * 	char			*un_rs_buffer;
	 */
} mm_unit32_od_t;
#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
#pragma pack()
#endif

/* Types of resync in progress (used for un_rs_type) */
#define	MD_RS_NONE		0		/* No resync */
#define	MD_RS_OPTIMIZED		0x0001		/* Optimized resync */
#define	MD_RS_COMPONENT		0x0002		/* Component resync */
#define	MD_RS_SUBMIRROR		0x0003		/* Submirror resync */
#define	MD_RS_ABR		0x0004		/* Application based resync */

/*
 * un_rs_type is split into the following bitfields:
 *
 * 0-3	Resync type (as above)
 * 4-7	Submirror index [0..3]
 * 8-31	Component index
 */
#define	RS_TYPE_MASK	0xF
#define	RS_SMI_MASK	0xF0
#define	RS_CI_MASK	0x1FFF00

#define	RS_TYPE(x)	((x) & RS_TYPE_MASK)
#define	RS_SMI(x)	(((x) & RS_SMI_MASK) >> 4)
#define	RS_CI(x)	(((x) & RS_CI_MASK) >> 8)

#define	SET_RS_TYPE(x, v)	{					\
				    (x) &= ~RS_TYPE_MASK;		\
				    (x) |= ((v) & RS_TYPE_MASK);	\
				}
#define	SET_RS_TYPE_NONE(x)	{					\
				    (x) &= ~RS_TYPE_MASK;		\
				}
#define	SET_RS_SMI(x, v)	{					\
				    (x) &= ~RS_SMI_MASK; 		\
				    (x) |= (((v) << 4) & RS_SMI_MASK);	\
				}
#define	SET_RS_CI(x, v)		{					\
				    (x) &= ~RS_CI_MASK;			\
				    (x) |= (((v) << 8) & RS_CI_MASK);	\
				}

typedef struct	mm_submirror_ic {
	intptr_t	(*sm_shared_by_blk)(md_dev64_t, void *,
				diskaddr_t, u_longlong_t *);
	intptr_t	(*sm_shared_by_indx)(md_dev64_t, void *, int);
	int		(*sm_get_component_count)(md_dev64_t, void *);
	int		(*sm_get_bcss)(md_dev64_t, void *, int, diskaddr_t *,
				size_t *, u_longlong_t *, u_longlong_t *);
} mm_submirror_ic_t;

typedef struct md_mps {
	DAEMON_QUEUE
	buf_t		*ps_bp;
	struct mm_unit	*ps_un;
	mdi_unit_t	*ps_ui;
	uint_t		 ps_childbflags;
	caddr_t		 ps_addr;
	diskaddr_t	 ps_firstblk;
	diskaddr_t	 ps_lastblk;
	uint_t		 ps_flags;
	uint_t		 ps_allfrom_sm;		/* entire read came from here */
	uint_t		 ps_writable_sm;
	uint_t		 ps_current_sm;
	uint_t		 ps_active_cnt;
	int		 ps_frags;
	uint_t		 ps_changecnt;
	struct md_mps	*ps_unused1;
	struct md_mps	*ps_unused2;
	void		 (*ps_call)();
	kmutex_t	 ps_mx;
	avl_node_t	ps_overlap_node;
} md_mps_t;

#define	MD_MPS_ON_OVERLAP	0x0001
#define	MD_MPS_ERROR		0x0002
#define	MD_MPS_WRITE_AFTER_READ	0x0004
#define	MD_MPS_WOW		0x0008
#define	MD_MPS_DONTFREE		0x0010
#define	MD_MPS_DONE		0x0020
#define	MD_MPS_MAPPED		0x0040		/* re: MD_STR_MAPPED	*/
#define	MD_MPS_NOBLOCK		0x0080		/* re: MD_NOBLOCK	*/
#define	MD_MPS_ABR		0x0100		/* re: MD_STR_ABR	*/
#define	MD_MPS_DMR		0x0200		/* re: MD_STR_DMR	*/
#define	MD_MPS_WMUPDATE		0x0400		/* re: MD_STR_WMUPDATE	*/
#define	MD_MPS_DIRTY_RD		0x0800		/* re: MD_STR_DIRTY_RD	*/
#define	MD_MPS_RESYNC_READ	0x1000
#define	MD_MPS_FLAG_ERROR	0x2000		/* re: MD_STR_FLAG_ERR	*/
#define	MD_MPS_BLOCKABLE_IO	0x4000		/* re: MD_STR_BLOCK_OK  */

#define	MPS_FREE(kc, ps)			\
{						\
	if ((ps)->ps_flags & MD_MPS_DONTFREE)	\
		(ps)->ps_flags |= MD_MPS_DONE;	\
	else					\
		kmem_cache_free((kc), (ps));	\
}

typedef struct md_mcs {
	DAEMON_QUEUE
	md_mps_t	*cs_ps;
	minor_t		 cs_mdunit;
	/* Add new structure members HERE!! */
	buf_t		 cs_buf;
	/*  DO NOT add structure members here; cs_buf is dynamically sized */
} md_mcs_t;

typedef struct  mm_mirror_ic {
	kmutex_t	un_overlap_tree_mx;
	kcondvar_t	un_overlap_tree_cv;
	avl_tree_t	un_overlap_root;
	kmutex_t	un_resync_mx;
	kcondvar_t	un_resync_cv;
	short		*un_outstanding_writes; /* outstanding write array */
	uchar_t		*un_goingclean_bm;
	uchar_t		*un_goingdirty_bm;
	uchar_t		*un_dirty_bm;
	uchar_t		*un_resync_bm;
	char		*un_rs_buffer;
	int		un_suspend_wr_flag;
	kmutex_t	un_suspend_wr_mx;
	kcondvar_t	un_suspend_wr_cv;
	md_mn_nodeid_t	un_mirror_owner;	/* Node which owns mirror */
	diskaddr_t	un_resync_startbl;	/* Start block for resync */
	kmutex_t	un_owner_mx;		/* Mutex for un_owner_state */
	uint_t		un_owner_state;		/* See below */
	uint_t		un_mirror_owner_status;	/* status for ioctl request */
	kmutex_t	un_dmr_mx;		/* mutex for DMR requests */
	kcondvar_t	un_dmr_cv;		/* condvar for DMR requests */
	int		un_dmr_last_read;	/* last DMR submirror read */
	callb_cpr_t	un_rs_cprinfo;		/* CPR info for resync thread */
	kmutex_t	un_rs_cpr_mx;		/* mutex for resync CPR info */
	kmutex_t	un_prr_cpr_mx;		/* mutex for prr CPR info */
	uint_t		un_resync_completed;	/* type of last resync */
	int		un_abr_count;		/* count of sp's with abr set */

	uchar_t		*un_pernode_dirty_bm[MD_MNMAXSIDES];
	uchar_t		*un_pernode_dirty_sum;

	krwlock_t	un_pernode_dirty_mx[MD_MNMAXSIDES];
	ushort_t	un_rr_clean_start_bit;  /* where to start next clean */

#ifdef	_KERNEL
	ddi_taskq_t	*un_drl_task;		/* deferred RR_CLEAN taskq */
#else
	void		*un_drl_task;		/* deferred RR_CLEAN taskq */
#endif	/* _KERNEL */
	uint_t		un_waiting_to_clear;	/* Blocked waiting to clear */

}mm_mirror_ic_t;

#define	MM_MN_OWNER_SENT	0x0001		/* RPC in progress */
#define	MM_MN_BECOME_OWNER	0x0002		/* Ownership change in prog. */
#define	MM_MN_PREVENT_CHANGE	0x0004		/* Disallow ownership change */

typedef struct mm_unit {
	mdc_unit_t	c;			/* common stuff */

	int		un_last_read;		/* last submirror index read */
	uint_t		un_changecnt;
	ushort_t	un_nsm;			/* number of submirrors */
	mm_submirror_t	un_sm[NMIRROR];
	int		un_overlap_tree_flag;
	mm_rd_opt_t	un_read_option;		/* mirror read option */
	mm_wr_opt_t	un_write_option;	/* mirror write option */
	mm_pass_num_t	un_pass_num;		/* resync pass number */
	/*
	 * following used to keep dirty bitmaps
	 */
	uint_t		un_resync_flg;
	uint_t		un_waiting_to_mark;
	uint_t		un_waiting_to_commit;
	uint_t		un_rrd_blksize;	  /* The blocksize of the dirty bits */
	uint_t		un_rrd_num;	  /* The number of resync regions */
	mddb_recid_t	un_rr_dirty_recid; /* resync region bm db record id */
	/*
	 * following stuff is private to resync process
	 */
	int 		un_rs_copysize;
	int 		un_rs_dests;		/* destinations */
	diskaddr_t	un_rs_resync_done;	/* used for percent done */
	diskaddr_t	un_rs_resync_2_do;	/* user for percent done */
	int		un_rs_dropped_lock;
	uint_t		un_rs_type;		/* type of resync */
	/*
	 * Incore only elements
	 */
	mm_submirror_ic_t un_smic[NMIRROR];	/* NMIRROR elements array */
	mm_mirror_ic_t	un_mmic;
	kmutex_t	un_rrp_inflight_mx;
	/*
	 * resync thread control
	 */
	kthread_t	*un_rs_thread;		/* Resync thread ID */
	kmutex_t	un_rs_thread_mx;	/* Thread cv mutex */
	kcondvar_t	un_rs_thread_cv;	/* Cond. Var. for thread */
	uint_t		un_rs_thread_flags;	/* Thread control flags */
	md_mps_t	*un_rs_prev_overlap;	/* existing overlap request */
	timeout_id_t	un_rs_resync_to_id;	/* resync progress timeout */
	kmutex_t	un_rs_progress_mx;	/* Resync progress mutex */
	kcondvar_t	un_rs_progress_cv;	/* Cond. Var. for progress */
	uint_t		un_rs_progress_flags;	/* Thread control flags */
	void		*un_rs_msg;		/* Intra-node resync message */
} mm_unit_t;

#define	un_overlap_tree_mx	un_mmic.un_overlap_tree_mx
#define	un_overlap_tree_cv	un_mmic.un_overlap_tree_cv
#define	un_overlap_root		un_mmic.un_overlap_root
#define	un_resync_mx		un_mmic.un_resync_mx
#define	un_resync_cv		un_mmic.un_resync_cv
#define	un_outstanding_writes	un_mmic.un_outstanding_writes
#define	un_goingclean_bm	un_mmic.un_goingclean_bm
#define	un_goingdirty_bm	un_mmic.un_goingdirty_bm
#define	un_dirty_bm		un_mmic.un_dirty_bm
#define	un_resync_bm		un_mmic.un_resync_bm
#define	un_rs_buffer		un_mmic.un_rs_buffer
#define	un_suspend_wr_mx	un_mmic.un_suspend_wr_mx
#define	un_suspend_wr_cv	un_mmic.un_suspend_wr_cv
#define	un_suspend_wr_flag	un_mmic.un_suspend_wr_flag
#define	un_mirror_owner		un_mmic.un_mirror_owner
#define	un_resync_startbl	un_mmic.un_resync_startbl
#define	un_owner_mx		un_mmic.un_owner_mx
#define	un_owner_state		un_mmic.un_owner_state
#define	un_mirror_reqs		un_mmic.un_mirror_reqs
#define	un_mirror_reqs_done	un_mmic.un_mirror_reqs_done
#define	un_mirror_owner_status	un_mmic.un_mirror_owner_status
#define	un_dmr_mx		un_mmic.un_dmr_mx
#define	un_dmr_cv		un_mmic.un_dmr_cv
#define	un_dmr_last_read	un_mmic.un_dmr_last_read
#define	un_rs_cprinfo		un_mmic.un_rs_cprinfo
#define	un_rs_cpr_mx		un_mmic.un_rs_cpr_mx
#define	un_prr_cpr_mx		un_mmic.un_prr_cpr_mx
#define	un_resync_completed	un_mmic.un_resync_completed
#define	un_abr_count		un_mmic.un_abr_count
#define	un_pernode_dirty_bm	un_mmic.un_pernode_dirty_bm
#define	un_pernode_dirty_sum	un_mmic.un_pernode_dirty_sum
#define	un_pernode_dirty_mx	un_mmic.un_pernode_dirty_mx
#define	un_rr_clean_start_bit	un_mmic.un_rr_clean_start_bit
#define	un_drl_task		un_mmic.un_drl_task
#define	un_waiting_to_clear	un_mmic.un_waiting_to_clear

#define	MM_RF_GATECLOSED	0x0001
#define	MM_RF_COMMIT_NEEDED	0x0002
#define	MM_RF_COMMITING		0x0004
#define	MM_RF_STALL_CLEAN	(MM_RF_COMMITING | \
				    MM_RF_COMMIT_NEEDED | \
				    MM_RF_GATECLOSED)


#define	MD_MN_MIRROR_UNOWNED	0
#define	MD_MN_MIRROR_OWNER(un)	 (un->un_mirror_owner == md_mn_mynode_id)
#define	MD_MN_NO_MIRROR_OWNER(un)	\
	(un->un_mirror_owner == MD_MN_MIRROR_UNOWNED)

typedef struct err_comp {
	struct err_comp	*ec_next;
	int		ec_smi;
	int		ec_ci;
} err_comp_t;

extern	int	md_min_rr_size;
extern	int	md_def_num_rr;

/* Optimized resync records controllers */
#define	MD_MIN_RR_SIZE		(md_min_rr_size)
#define	MD_DEF_NUM_RR		(md_def_num_rr)
#define	MD_MAX_NUM_RR		(4192*NBBY - sizeof (struct optim_resync))

/* default resync buffer size */
#define	MD_DEF_RESYNC_BUF_SIZE	(1024)

/* Structure for optimized resync records */
#define	OR_MAGIC	0xFECA	/* Only missing the L */
typedef struct optim_resync {
	uint_t	or_revision;
	uint_t	or_magic;
	uint_t	or_blksize;
	uint_t	or_num;
	uchar_t	or_rr[1];
} optim_resync_t;

/* Type 2 for mirror records */
#define	MIRROR_REC	1
#define	RESYNC_REC	2

#ifdef _KERNEL

#define	NO_SUBMIRRORS	(0)
#define	ALL_SUBMIRRORS	(0xFFF)
#define	SMI2BIT(smi)	(1 << (smi))

/* For use with mirror_other_sources() */
#define	WHOLE_SM	(-1)

#define	BLK_TO_RR(i, b, un)  {\
	(i) = ((b) / ((un))->un_rrd_blksize); \
	if ((i) > ((un))->un_rrd_num) \
		{ panic("md: BLK_TO_RR"); } \
}

#define	RR_TO_BLK(b, i, un) \
	(b) = ((i) * ((un))->un_rrd_blksize)

#define	IS_GOING_DIRTY(i, un)	(isset((un)->un_goingdirty_bm, (i)))
#define	CLR_GOING_DIRTY(i, un)	(clrbit((un)->un_goingdirty_bm, (i)))
#define	SET_GOING_DIRTY(i, un)	(setbit((un)->un_goingdirty_bm, (i)))

#define	IS_GOING_CLEAN(i, un)	(isset((un)->un_goingclean_bm, (i)))
#define	CLR_GOING_CLEAN(i, un)	(clrbit((un)->un_goingclean_bm, (i)))
#define	SET_GOING_CLEAN(i, un)	(setbit((un)->un_goingclean_bm, (i)))

#define	IS_REGION_DIRTY(i, un)	(isset((un)->un_dirty_bm, (i)))
#define	CLR_REGION_DIRTY(i, un)	(clrbit((un)->un_dirty_bm, (i)))
#define	SET_REGION_DIRTY(i, un)	(setbit((un)->un_dirty_bm, (i)))

#define	IS_KEEPDIRTY(i, un)	(isset((un)->un_resync_bm, (i)))
#define	CLR_KEEPDIRTY(i, un)	(clrbit((un)->un_resync_bm, (i)))

#define	IS_PERNODE_DIRTY(n, i, un) \
	(isset((un)->un_pernode_dirty_bm[(n)-1], (i)))
#define	CLR_PERNODE_DIRTY(n, i, un) \
	(clrbit((un)->un_pernode_dirty_bm[(n)-1], (i)))
#define	SET_PERNODE_DIRTY(n, i, un) \
	(setbit((un)->un_pernode_dirty_bm[(n)-1], (i)))

/*
 * Write-On-Write handling.
 *   flags for md_mirror_wow_flg
 *   structure for quing copy-writes
 *   macros for relative locating of header and buffer
 */
#define	WOW_DISABLE	0x0001	/* turn off WOW detection */
#define	WOW_PHYS_ENABLE	0x0020	/* turn on WOW for PHYS */
#define	WOW_LOGIT	0x0002	/* log non-disabled WOW detections */
#define	WOW_NOCOPY	0x0004	/* repeat normal write on WOW detection */

typedef	struct wowhdr {
	DAEMON_QUEUE
	md_mps_t	*wow_ps;
	int		wow_offset;
} wowhdr_t;

#define	WOWBUF_HDR(wowbuf)	((void *)(wowbuf-sizeof (wowhdr_t)))
#define	WOWHDR_BUF(wowhdr)	((char *)wowhdr+sizeof (wowhdr_t))

/*
 * Structure used to to save information about DMR reads.  Used to save
 * the count of all DMR reads and the timestamp of the last one executed.
 * We declare a global with this structure and it can be read by a debugger to
 * verify that the DMR ioctl has been executed and the number of times that it
 * has been executed.
 */
typedef struct dmr_stats {
	uint_t		dmr_count;
	struct timeval	dmr_timestamp;
} dmr_stats_t;

/* Externals from mirror.c */
extern mddb_recid_t	mirror_get_sm_unit(md_dev64_t);
extern void		mirror_release_sm_unit(md_dev64_t);

extern void		mirror_set_sm_state(mm_submirror_t *,
				mm_submirror_ic_t *, sm_state_t, int);

extern void		mirror_commit(mm_unit_t *, int, mddb_recid_t *);
extern int		poke_hotspares(void);
extern void		build_submirror(mm_unit_t *, int, int);
extern int		mirror_build_incore(mm_unit_t *, int);
extern void		reset_mirror(mm_unit_t *, minor_t, int);
extern int		mirror_internal_open(minor_t, int, int, int, IOLOCK *);
extern int		mirror_internal_close(minor_t, int, int, IOLOCK *);
extern void		set_sm_comp_state(mm_unit_t *, int, int, int,
			    mddb_recid_t *, uint_t, IOLOCK *);
extern int		mirror_other_sources(mm_unit_t *, int, int, int);
extern int		mirror_resync_message(md_mn_rs_params_t *, IOLOCK *);
extern void		md_mirror_strategy(buf_t *, int, void *);
extern int		mirror_directed_read(dev_t, vol_directed_rd_t *, int);
extern void		mirror_check_failfast(minor_t mnum);
extern int		check_comp_4_hotspares(mm_unit_t *, int, int, uint_t,
			    mddb_recid_t, IOLOCK *);
extern void		mirror_overlap_tree_remove(md_mps_t *ps);
extern void		mirror_child_init(md_mcs_t *cs);

/* Externals from mirror_ioctl.c */
extern void		reset_comp_states(mm_submirror_t *,
			    mm_submirror_ic_t *);
extern int		mirror_grow_unit(mm_unit_t *un, md_error_t *ep);
extern int		md_mirror_ioctl(dev_t dev, int cmd, void *data,
			    int mode, IOLOCK *lockp);
extern mm_unit_t	*mirror_getun(minor_t, md_error_t *, int, IOLOCK *);
extern void		mirror_get_status(mm_unit_t *un, IOLOCK *lockp);
extern int		mirror_choose_owner(mm_unit_t *un, md_mn_req_owner_t *);

/* rename named service functions */
md_ren_list_svc_t	mirror_rename_listkids;
md_ren_svc_t		mirror_rename_check;
md_ren_roleswap_svc_t	mirror_renexch_update_kids;
md_ren_roleswap_svc_t	mirror_exchange_parent_update_to;
md_ren_roleswap_svc_t	mirror_exchange_self_update_from_down;

/* Externals from mirror_resync.c */
extern int		unit_setup_resync(mm_unit_t *, int);
extern int		mirror_resync_unit(minor_t mnum, md_resync_ioctl_t *ri,
			    md_error_t *ep, IOLOCK *);
extern int		mirror_ioctl_resync(md_resync_ioctl_t *p, IOLOCK *);
extern int		mirror_mark_resync_region(mm_unit_t *, diskaddr_t,
				diskaddr_t, md_mn_nodeid_t);
extern void		resync_start_timeout(set_t setno);
extern int		mirror_resize_resync_regions(mm_unit_t *, diskaddr_t);
extern int		mirror_add_resync_regions(mm_unit_t *, diskaddr_t);
extern int		mirror_probedevs(md_probedev_t *, IOLOCK *);
extern void		mirror_copy_rr(int, uchar_t *, uchar_t *);
extern void		mirror_process_unit_resync(mm_unit_t *);
extern int		mirror_set_dirty_rr(md_mn_rr_dirty_params_t *);
extern int		mirror_set_clean_rr(md_mn_rr_clean_params_t *);
#endif	/* _KERNEL */

#ifdef	__cplusplus
}
#endif

#endif	/* _SYS_MD_MIRROR_H */