path: root/usr/src/uts/common/sys/lvm/md_trans.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_MD_TRANS_H
#define	_SYS_MD_TRANS_H

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/lvm/mdvar.h>
#include <sys/buf.h>
#include <sys/fs/ufs_trans.h>
#include <sys/lvm/md_rename.h>

#ifdef	__cplusplus
extern "C" {
#endif

#define	LDL_META_SBLK		(16)

#define	LDL_MINLOGSIZE		(1024*1024)
#define	LDL_MAXLOGSIZE		(1024*1024*1024)
#define	LDL_MINBUFSIZE		(32*1024)
#define	LDL_USABLE_BSIZE	(DEV_BSIZE - sizeof (sect_trailer_t))
#define	NB_LEFT_IN_SECTOR(off) 	(LDL_USABLE_BSIZE - ((off) - dbtob(btodb(off))))

typedef struct cirbuf32 {
	caddr32_t	xx_cb_bp;	/* buf's with space in circular buf */
	caddr32_t	xx_cb_dirty;	/* filling this buffer for log write */
	caddr32_t	xx_cb_free;	/* free bufs list */
	caddr32_t	xx_cb_va;	/* address of circular buffer */
	uint_t		xx_cb_nb;	/* size of circular buffer */
	uint_t		xx_cb_rwlock[3]; /* r/w lock to protect list mgmt. */
} cirbuf32_t;

typedef struct cirbuf_ic {
	buf_t		*cb_bp;		/* buf's with space in circular buf */
	buf_t		*cb_dirty;	/* filling this buffer for log write */
	buf_t		*cb_free;	/* free bufs list */
	caddr_t		cb_va;		/* address of circular buffer */
	size_t		cb_nb;		/* size of circular buffer */
	md_krwlock_t	cb_rwlock;	/* r/w lock to protect list mgmt. */
} cirbuf_ic_t;


typedef struct ml_unit {
	uint_t		un_revision;	/* revision number */
	/*
	 * mdd infrastructure stuff
	 */
	mddb_recid_t	un_recid;	/* db record id */
	mdkey_t		un_key;		/* namespace key */
	md_dev64_t	un_dev;		/* device number */
	uint_t		un_opencnt;	/* open count */

	/*
	 * metatrans infrastructure stuff
	 */
	uint_t		un_transcnt;	/* #open metatrans devices */

	/*
	 * log specific stuff
	 */
	off32_t		un_head_lof;	/* byte offset of head */
	uint_t		un_head_ident;	/* head sector id # */
	off32_t		un_tail_lof;	/* byte offset of tail */
	uint_t		un_tail_ident;	/* tail sector id # */
	off32_t		un_bol_lof;	/* byte offset of begin of log */
	off32_t		un_eol_lof;	/* byte offset of end of log */
	daddr32_t	un_nblks;	/* total blocks of log space */
	daddr32_t	un_tblks;	/* total blocks in log device */
	uint_t		un_maxtransfer;	/* max transfer in bytes */
	uint_t		un_status;	/* status bits */
	uint_t		un_maxresv;	/* maximum reservable space */
	daddr32_t	un_pwsblk;	/* block number of prewrite area */
	ulong_t		un_devbsize;	/* device bsize */
	uint_t		un_resv;	/* reserved byte count for this trans */
	uint_t		un_resv_wantin;	/* reserved byte count for next trans */
	mt_l_error_t	un_error;	/* error state */
	uint_t		un_tid;		/* used during logscan */
	uint_t		un_head_tid;	/* used for logscan; set at sethead */
	struct timeval32 un_timestamp;	/* time of last state change */
	/*
	 * spares
	 */
	uint_t		un_spare[16];
	/*
	 * following are incore only elements.
	 * Incore elements must always be at the end
	 * of this data struture.
	 */
	struct ml_unit	*un_next;
	struct mt_unit	*un_utlist;
	struct mt_map	*un_logmap;
	cirbuf_ic_t	un_rdbuf;
	cirbuf_ic_t	un_wrbuf;
	kmutex_t	un_log_mutex;
} ml_unit_t;


#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
#pragma pack(4)
#endif
typedef struct ml_unit32_od {
	uint_t		un_revision;	/* revision number */
	/*
	 * mdd infrastructure stuff
	 */
	caddr32_t	xx_un_next;	/* next log unit struct */
	mddb_recid_t	un_recid;	/* db record id */
	mdkey_t		un_key;		/* namespace key */
	dev32_t		un_dev;		/* device number */
	uint_t		un_opencnt;	/* open count */

	/*
	 * metatrans infrastructure stuff
	 */
	uint_t		un_transcnt;	/* #open metatrans devices */
	caddr32_t	xx_un_utlist;	/* list of metatrans devices */
	caddr32_t	xx_un_logmap;	/* address of logmap */

	/*
	 * log specific stuff
	 */
	off32_t		un_head_lof;	/* byte offset of head */
	uint_t		un_head_ident;	/* head sector id # */
	off32_t		un_tail_lof;	/* byte offset of tail */
	uint_t		un_tail_ident;	/* tail sector id # */
	off32_t		un_bol_lof;	/* byte offset of begin of log */
	off32_t		un_eol_lof;	/* byte offset of end of log */
	daddr32_t	un_nblks;	/* total blocks of log space */
	daddr32_t	un_tblks;	/* total blocks in log device */
	uint_t		un_maxtransfer;	/* max transfer in bytes */
	uint_t		un_status;	/* status bits */
	uint_t		un_maxresv;	/* maximum reservable space */
	daddr32_t	un_pwsblk;	/* block number of prewrite area */
	uint_t		un_devbsize;	/* device bsize */
	uint_t		un_resv;	/* reserved byte count for this trans */
	uint_t		un_resv_wantin;	/* reserved byte count for next trans */
	mt_l_error_t	un_error;	/* error state */
	uint_t		un_tid;		/* used during logscan */
	uint_t		un_head_tid;	/* used for logscan; set at sethead */
	cirbuf32_t	xx_un_rdbuf;	/* read buffer space */
	cirbuf32_t	xx_un_wrbuf;	/* write buffer space */
	int		xx_un_log_mutex[2]; /* allows one log write at a time */
	struct timeval32 un_timestamp;	/* time of last state change */
	/*
	 * spares
	 */
	uint_t		un_spare[16];
} ml_unit32_od_t;
#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
#pragma pack()
#endif



#define	ML_UNIT_ONDSZ	((size_t)((caddr_t)&((ml_unit_t *)0)->un_spare[15] +\
				sizeof (uint_t)))


/*
 *	un_status
 */
#define	LDL_BEING_RESET	0x0001	/* delete the log record at snarf */
#define	LDL_FIND_TAIL	0x0002	/* find tail of the log */
#define	LDL_SCAN_ACTIVE	0x0004	/* log scan in progress */
#define	LDL_METADEVICE	0x0008	/* underlying device is metadevice */
#define	LDL_PWVALID	0x0010	/* prewrite area is valid */
#define	LDL_INFO	0x0020	/* prewrite state is valid */

typedef struct sect_trailer {
	uint_t		st_tid;		/* transaction id */
	uint_t		st_ident;	/* unique sector id */
} sect_trailer_t;


/*
 * ioctls
 */
#define	MD_IOCGET_LOG		(MDIOC_MISC|0)
#define	MD_IOC_DEBUG		(MDIOC_MISC|4)
#define	MD_IOCGET_TRANSSTATS	(MDIOC_MISC|5)
#define	MD_IOC_TSD		(MDIOC_MISC|6)
#define	MD_IOC_TRYGETBLK	(MDIOC_MISC|7)
#define	MD_IOC_TRYPAGE		(MDIOC_MISC|8)
#define	MD_IOC_SETSHADOW	(MDIOC_MISC|11)
#define	MD_IOC_INJECTERRORS	(MDIOC_MISC|13)
#define	MD_IOC_STOPERRORS	(MDIOC_MISC|14)
#define	MD_IOC_UFSERROR		(MDIOC_MISC|15)
#define	MD_IOC_ISDEBUG		(MDIOC_MISC|17)

#define	MD_IOC_TRANS_DETACH	(MDIOC_MISC|32)

/*
 * following bits are used in status word in the common section
 * of unit structure
 */
#define	MD_UN_LOG_DELETED	(0x00010000)	/* don't need to del @snarf */

/*
 * map block
 */
#define	MAPBLOCKSIZE	(8192)
#define	MAPBLOCKSHIFT	(13)
#define	MAPBLOCKOFF	(MAPBLOCKSIZE-1)
#define	MAPBLOCKMASK	(~MAPBLOCKOFF)

/*
 * delta header
 */
struct delta {
	offset_t	d_mof;
	off32_t		d_nb;
	dev32_t		d_dev;
	delta_t 	d_typ;
};

/*
 * common map entry
 */
typedef struct mapentry	mapentry_t;
struct mapentry {
	/*
	 * doubly linked list of all mapentries in map -- MUST BE FIRST
	 */
	mapentry_t	*me_next;
	mapentry_t	*me_prev;

	mapentry_t	*me_hash;
	mapentry_t	*me_agenext;
	mapentry_t	*me_cancel;
	int		(*me_func)();
	uintptr_t	me_arg;
	off_t		me_lof;
	uint_t		me_flags;
	uint_t		me_tid;
	uint_t		me_age;
	struct delta	me_delta;
};

#define	me_mof	me_delta.d_mof
#define	me_nb	me_delta.d_nb
#define	me_dt	me_delta.d_typ
#define	me_dev	me_delta.d_dev

/*
 * me_flags
 */
#define	ME_FREE		(0x0001)	/* on free   list */
#define	ME_HASH		(0x0002)	/* on hash   list */
#define	ME_CANCEL	(0x0004)	/* on cancel list */
#define	ME_AGE		(0x0008)	/* on age    list */
#define	ME_LIST		(0x0010)	/* on list   list */
#define	ME_ROLL		(0x0020)	/* on pseudo-roll list */

/*
 * TRANSACTION OPS STATS
 * mt_top_size_* should be 64bit but that would
 * require test recompilations. It does not hurt the kernel
 * so leave as 32 bit for now.
 */
struct topstats {
	uint_t		mtm_top_num[TOP_MAX];
	uint_t		mtm_top_size_etot[TOP_MAX];
	uint_t		mtm_top_size_rtot[TOP_MAX];
	uint_t		mtm_top_size_max[TOP_MAX];
	uint_t		mtm_top_size_min[TOP_MAX];
	uint_t		mtm_delta_num[DT_MAX];
};

/*
 * MAP STATS (global struct that is not updated if compiled w/o ASSERTs)
 * some members of transstats need to be 64bit. See the comment above.
 */
struct transstats {
	/* trans.c */
	uint_t		ts_trans_zalloc;
	uint_t		ts_trans_zalloc_nosleep;
	uint_t		ts_trans_alloc;
	uint_t		ts_trans_alloc_nosleep;
	uint_t		ts_trans_free;
	uint_t		ts_trans_alloced;
	uint_t		ts_trans_freed;
	uint_t		ts_trans_write;
	uint_t		ts_trans_write_roll;

	/* trans_delta.c */
	uint_t		ts_mapentry_alloc;
	uint_t		ts_mapentry_alloc_list;
	uint_t		ts_mapentry_free;

	uint_t		ts_delta_add;
	uint_t		ts_delta_add_scan;
	uint_t		ts_delta_add_hit;

	uint_t		ts_delta_remove;
	uint_t		ts_delta_remove_scan;
	uint_t		ts_delta_remove_hit;

	uint_t		ts_delta_del;
	uint_t		ts_delta_del_scan;

	uint_t		ts_delta_push;

	uint_t		ts_overlap;
	uint_t		ts_overlap_scan;
	uint_t		ts_overlap_hit;

	uint_t		ts_remove_roll;
	uint_t		ts_remove_roll_scan;
	uint_t		ts_remove_roll_hit;
	uint_t		ts_remove_roll_dolock;
	uint_t		ts_remove_roll_sud;

	uint_t		ts_next_roll;
	uint_t		ts_next_roll_scan;
	uint_t		ts_next_roll_hit;

	uint_t		ts_list_age;
	uint_t		ts_list_age_scan;

	uint_t		ts_list_get;
	uint_t		ts_list_get_scan;
	uint_t		ts_list_get_hit;
	uint_t		ts_list_get_again;

	uint_t		ts_list_put;
	uint_t		ts_list_put_scan;

	uint_t		ts_read_mstr;

	uint_t		ts_logmap_secmap_roll;

	uint_t		ts_read_log;

	uint_t		ts_logmap_abort;
	uint_t		ts_logmap_abort_hit;

	uint_t		ts_list_add;
	uint_t		ts_list_add_scan;
	uint_t		ts_list_add_cancel;
	uint_t		ts_list_add_unhash;

	uint_t		ts_free_cancel;
	uint_t		ts_free_cancel_again;
	uint_t		ts_free_cancel_scan;
	uint_t		ts_free_cancel_hit;

	uint_t		ts_commit;
	uint_t		ts_commit_hit;

	uint_t		ts_logmap_roll_dev;
	uint_t		ts_logmap_roll_dev_scan;
	uint_t		ts_logmap_roll_dev_hit;

	uint_t		ts_logmap_roll_sud;
	uint_t		ts_logmap_roll_sud_hit;

	uint_t		ts_logmap_ud_done;
	uint_t		ts_logmap_ud_done_scan;

	uint_t		ts_logmap_ud_wait;
	uint_t		ts_logmap_ud_wait_hit;

	uint_t		ts_logmap_ud_commit;
	uint_t		ts_logmap_ud_commit_scan;

	uint_t		ts_logmap_cancel;
	uint_t		ts_logmap_cancel_scan;
	uint_t		ts_logmap_cancel_hit;

	uint_t		ts_logmap_iscancel;
	uint_t		ts_logmap_iscancel_scan;
	uint_t		ts_logmap_iscancel_hit;

	uint_t		ts_logscan;
	uint_t		ts_logscan_ud;
	uint_t		ts_logscan_delta;
	uint_t		ts_logscan_cancel;
	uint_t		ts_logscan_commit;

	/* trans_thread.c */
	uint_t		ts_prewrite;
	uint_t		ts_prewrite_read;
	uint_t		ts_prewrite_write;
	uint_t		ts_trans_roll;
	uint_t		ts_trans_roll_wait;
	uint_t		ts_trans_roll_wait_nada;
	uint_t		ts_trans_roll_wait_slow;
	uint_t		ts_trans_roll_force;
	uint_t		ts_trans_roll_nsud;
	uint_t		ts_trans_roll_ref;
	uint_t		ts_trans_roll_full;
	uint_t		ts_trans_roll_logmap;
	uint_t		ts_trans_roll_read;
	uint_t		ts_trans_roll_reread;
	uint_t		ts_trans_roll_wait_inuse;
	uint_t		ts_trans_roll_prewrite;
	uint_t		ts_trans_roll_write;

	/* trans_top.c */
	uint_t		ts_delta;
	uint_t		ts_ud_delta;
	uint_t		ts_ud_delta_log;
	uint_t		ts_cancel;
	uint_t		ts_iscancel;
	uint_t		ts_error;
	uint_t		ts_iserror;
	uint_t		ts_beginsync;
	uint_t		ts_active;
	uint_t		ts_activesync;
	uint_t		ts_beginasync;
	uint_t		ts_endsync;
	uint_t		ts_wantin;
	uint_t		ts_endasync;
	uint_t		ts_read;
	uint_t		ts_read_roll;
	uint_t		ts_readmt;
	uint_t		ts_write;
	uint_t		ts_writemt;
	uint_t		ts_writemt_done;
	uint_t		ts_log;

	/* trans_log.c */
	uint_t		ts_logcommitdb;

	uint_t		ts_push_dirty_bp;
	uint_t		ts_push_dirty_bp_extra;
	uint_t		ts_push_dirty_bp_fail;

	uint_t		ts_alloc_bp;
	uint_t		ts_alloc_bp_free;

	uint_t		ts_find_bp;
	uint_t		ts_find_bp_scan;
	uint_t		ts_find_bp_hit;

	uint_t		ts_find_read_lof;
	uint_t		ts_find_read_lof_scan;
	uint_t		ts_find_read_lof_hit;

	uint_t		ts_get_read_bp;
	uint_t		ts_get_read_bp_wr;
	uint_t		ts_get_read_bp_rd;

	uint_t		ts_extend_write_bp;
	uint_t		ts_extend_write_bp_hit;

	uint_t		ts_storebuf;
	uint_t		ts_fetchbuf;
	uint_t		ts_round_commit;
	uint_t		ts_push_commit;

	uint_t		ts_inval_range;
	uint_t		ts_inval_range_scan;
	uint_t		ts_inval_range_hit;

	uint_t		ts_writelog;
	uint_t		ts_writelog_max;

	uint_t		ts_readlog;
	uint_t		ts_readlog_max;

	uint_t		ts_get_write_bp;
	uint_t		ts_get_write_bp_steal;

	uint_t		ts_writesync;
	uint_t		ts_writesync_log;
	uint_t		ts_writesync_nolog;

	uint_t		ts_longmof_cnt;

} transstats;

#ifdef	DEBUG
#define	TRANSSTATS(f)		(transstats.f++)
#define	TRANSSTATSADD(f, n)	(transstats.f += (n))
#define	TRANSSTATSMAX(m, v)	\
		if ((v) > transstats.m)\
			transstats.m = (v);
#else
#define	TRANSSTATS(f)
#define	TRANSSTATSADD(f, n)
#define	TRANSSTATSMAX(m, v)
#endif /* DEBUG */

/*
 * MAP TYPES
 */
enum maptypes	{
	deltamaptype, udmaptype, logmaptype, matamaptype, shadowmaptype
};

/*
 * MAP
 */
#define	DELTAMAP_NHASH	(512)
#define	LOGMAP_NHASH	(2048)
#define	MAP_INDEX(dev, mof, mtm) \
	((((mof) >> MAPBLOCKSHIFT) + (dev)) & ((mtm)->mtm_nhash-1))
#define	MAP_HASH(dev, mof, mtm) \
	(mtm->mtm_hash + MAP_INDEX(dev, mof, mtm))

typedef struct mt_map {
	/*
	 * anchor doubly linked list this map's entries -- MUST BE FIRST
	 */
	mapentry_t	*mtm_next;
	mapentry_t	*mtm_prev;

	int		mtm_flags;	/* generic flags */
	int		mtm_ref;	/* PTE like ref bit */
	uint_t		mtm_debug;	/* set at create time */
	uint_t		mtm_age;	/* mono-inc; tags mapentries */
	mapentry_t	*mtm_cancel;	/* to be canceled at commit */
	uint_t		mtm_nhash;	/* # of hash anchors */
	mapentry_t	**mtm_hash;	/* array of singly linked lists */
	struct topstats	*mtm_tops;	/* trans ops - enabled by an ioctl */
	int		mtm_nme;	/* # of mapentries */
	int		mtm_nmet;	/* # of mapentries this transaction */
	int		mtm_nud;	/* # of active userdata writes */
	int		mtm_nsud;	/* # of userdata scanned deltas */
	md_dev64_t	mtm_dev;	/* device identifying map */

	/*
	 * the following are protected by the global map_mutex
	 */
	struct mt_map	*mtm_mapnext;	/* singly linked list of all maps */
	uint_t		mtm_refcnt;	/* reference count to this map */
	enum maptypes	mtm_type;	/* type of map */

	/*
	 * used after logscan to set the log's tail
	 */
	off_t		mtm_tail_lof;
	size_t		mtm_tail_nb;

	/*
	 * debug field for Scan test
	 */
	off_t		mtm_trimlof;	/* log was trimmed to this lof */
	off_t		mtm_trimtail;	/* tail lof before trimming */
	off_t		mtm_trimalof;	/* lof of last allocation delta */
	off_t		mtm_trimclof;	/* lof of last commit delta */
	off_t		mtm_trimrlof;	/* lof of last rolled delta */
	struct ml_unit	*mtm_ul;	/* log unit for this map */

	/*
	 * moby trans stuff
	 */
	uint_t			mtm_tid;
	uint_t			mtm_committid;
	ushort_t		mtm_closed;
	ushort_t		mtm_seq;
	int			mtm_wantin;
	int			mtm_active;
	int			mtm_activesync;
	uint_t			mtm_dirty;
	kmutex_t		mtm_lock;
	kcondvar_t		mtm_cv_commit;
	kcondvar_t		mtm_cv_next;
	kcondvar_t		mtm_cv_eot;

	/*
	 * mutex that protects all the fields in mt_map except
	 * mtm_mapnext and mtm_refcnt
	 */
	kmutex_t	mtm_mutex;
	kcondvar_t	mtm_cv;		/* generic conditional */

	/*
	 * rw lock for the mapentry fields agenext and locnext
	 */
	md_krwlock_t	mtm_rwlock;
	/*
	 * DEBUG: runtestscan
	 */
	kmutex_t	mtm_scan_mutex;
} mt_map_t;

/*
 * mtm_flags
 */
#define	MTM_ROLL_EXIT		(0x00000001)
#define	MTM_ROLL_RUNNING	(0x00000002)
#define	MTM_FORCE_ROLL		(0x00000004)

/*
 * Generic range checking macros
 */
#define	OVERLAP(sof, snb, dof, dnb) \
	((sof >= dof && sof < (dof + dnb)) || \
	(dof >= sof && dof < (sof + snb)))

#define	WITHIN(sof, snb, dof, dnb) ((sof >= dof) && ((sof+snb) <= (dof+dnb)))

#define	DATAoverlapME(mof, hnb, me) (OVERLAP(mof, hnb, me->me_mof, me->me_nb))
#define	MEwithinDATA(me, mof, hnb) (WITHIN(me->me_mof, me->me_nb, mof, hnb))
#define	DATAwithinME(mof, hnb, me) (WITHIN(mof, hnb, me->me_mof, me->me_nb))


typedef struct mt_unit {
	struct mdc_unit	c;		/* common stuff */
	/*
	 * infrastructure
	 */
	mt_flags_t	un_flags;
	/*
	 * log and master device
	 */
	mdkey_t		un_m_key;
	md_dev64_t	un_m_dev;
	mdkey_t		un_l_key;
	md_dev64_t	un_l_dev;
	daddr32_t	un_l_sblk;	/* start block */
	daddr32_t	un_l_pwsblk;	/* prewrite start block */
	daddr32_t	un_l_nblks;	/* # of usable log blocks */
	daddr32_t	un_l_tblks;	/* total log blocks */
	daddr32_t	un_l_head;	/* sector offset of log head */
	daddr32_t	un_l_tail;	/* sector offset of log tail */
	uint_t		un_l_resv;	/* current log reservations */
	uint_t		un_l_maxresv;	/* max log reservations */
	uint_t		un_l_maxtransfer; /* maximum transfer at init */
	mddb_recid_t	un_l_recid;	/* database id */
	mt_l_error_t	un_l_error;	/* error state */
	struct timeval32 un_l_timestamp; /* time of last log state chg */
	md_dev64_t	un_s_dev;	/* shadow device for testing only */
	mt_debug_t	un_debug;	/* debug flags; set at create */
	md_dev64_t	un_dev;		/* this metatrans device */
	int		un_logreset;	/* part of _FIOLOGRESET ioctl stuff */
	struct timeval32 un_timestamp;	/* time of last trans state change */
	/*
	 * spares
	 */
	ulong_t		un_spare[16];
	/*
	 * following are incore only elements.
	 * Incore elements must always be at the end
	 * of this data struture.
	 */
	struct mt_unit	*un_next;
	struct ml_unit	*un_l_unit;
	struct ufstrans *un_ut;
	mt_map_t	*un_deltamap;
	mt_map_t	*un_udmap;
	mt_map_t	*un_logmap;
	mt_map_t	*un_matamap;
	mt_map_t	*un_shadowmap;
} mt_unit_t;


typedef struct mt_unit32_od {
	mdc_unit32_od_t	c;		/* common stuff */
	/*
	 * infrastructure
	 */
	mt_flags_t	un_flags;
	caddr32_t	xx_un_next;	/* anchored in log unit */
	/*
	 * log and master device
	 */
	mdkey_t		un_m_key;
	dev32_t		un_m_dev;
	mdkey_t		un_l_key;
	dev32_t		un_l_dev;
	daddr32_t	un_l_sblk;	/* start block */
	daddr32_t	un_l_pwsblk;	/* prewrite start block */
	daddr32_t	un_l_nblks;	/* # of usable log blocks */
	daddr32_t	un_l_tblks;	/* total log blocks */
	daddr32_t	un_l_head;	/* sector offset of log head */
	daddr32_t	un_l_tail;	/* sector offset of log tail */
	uint_t		un_l_resv;	/* current log reservations */
	uint_t		un_l_maxresv;	/* max log reservations */
	uint_t		un_l_maxtransfer; /* maximum transfer at init */
	mddb_recid_t	un_l_recid;	/* database id */
	caddr32_t	xx_un_l_unit;	/* log device unit struct */
	mt_l_error_t	un_l_error;	/* error state */
	struct timeval32 un_l_timestamp;	/* time of last log state chg */
	dev32_t		un_s_dev;	/* shadow device for testing only */

	mt_debug_t	un_debug;	/* debug flags; set at create */
	caddr32_t	xx_un_ut;	/* ufstrans struct */
	dev32_t		un_dev;		/* this metatrans device */
	caddr32_t	xx_un_deltamap;	/* deltamap */
	caddr32_t	xx_un_udmap;	/* userdata map */
	caddr32_t	xx_un_logmap;	/* logmap includes moby trans stuff */
	caddr32_t	xx_un_matamap;	/* optional - matamap */
	caddr32_t	xx_un_shadowmap; /* optional - shadowmap */
	int		un_logreset;	/* part of _FIOLOGRESET ioctl stuff */
	struct timeval32 un_timestamp;	/* time of last trans state change */
	/*
	 * spares
	 */
	uint_t		un_spare[16];
} mt_unit32_od_t;

/*
 * prewrite info (per buf); stored as array at beginning of prewrite area
 */
struct prewrite {
	int		pw_bufsize;	/* every buffer is this size */
	daddr32_t	pw_blkno;	/* block number */
	dev32_t		pw_dev;		/* device to write to */
	ushort_t	pw_secmap;	/* bitmap 	*/
					/* 1's write this sector in the buf */
	ushort_t	pw_flags;
};
/*
 * pw_flags
 */
#define	PW_INUSE	0x0001	/* this prewrite buf is in use */
#define	PW_WAIT		0x0002	/* write in progress; wait for completion */
#define	PW_REM		0x0004	/* remove deltas */

/*
 * log state
 */
struct  logstate {
	off32_t		ls_head_lof;	/* log head */
	uint_t		ls_head_ident;	/* log head ident */
	uint_t		ls_head_tid;	/* log head tid */
	uint_t		ls_chksum;	/* checksum of structure */
	off32_t		ls_bol_lof;	/* needed for TS_Tools/dumplog.c */
	off32_t		ls_eol_lof;	/* needed for TS_Tools/dumplog.c */
	uint_t		ls_maxtransfer;	/* needed for TS_Tools/dumplog.c */
	daddr32_t	ls_pwsblk;	/* needed for TS_Tools/dumplog.c */
};

/*
 * log state defines
 */
#define	LS_SECTORS	(2)	/* number of sectors used by state area */

/*
 * un_debug
 *	MT_TRANSACT		- keep per thread accounting of tranactions
 *	MT_MATAMAP		- double check deltas and ops against matamap
 *	MT_WRITE_CHECK		- check master+deltas against metadata write
 *	MT_LOG_WRITE_CHECK	- read after write for log writes
 *	MT_CHECK_MAP		- check map after every insert/delete
 *	MT_TRACE		- trace transactions (used with MT_TRANSACT)
 *	MT_SIZE			- fail on size errors (used with MT_TRANSACT)
 *	MT_NOASYNC		- force every op to be sync
 *	MT_FORCEROLL		- forcibly roll the log after every commit
 *	MT_SCAN			- running runtestscan; special case as needed
 *	MT_SHADOW		- copy metatrans device writes to shadow dev.
 *	MT_PREWRITE		- process prewrite area every roll
 */
#define	MT_TRANSACT		(0x00000001)
#define	MT_MATAMAP		(0x00000002)
#define	MT_WRITE_CHECK		(0x00000004)
#define	MT_LOG_WRITE_CHECK	(0x00000008)
#define	MT_CHECK_MAP		(0x00000010)
#define	MT_TRACE		(0x00000020)
#define	MT_SIZE			(0x00000040)
#define	MT_NOASYNC		(0x00000080)
#define	MT_FORCEROLL		(0x00000100)
#define	MT_SCAN			(0x00000200)
#define	MT_SHADOW		(0x00000400)
#define	MT_PREWRITE		(0x00000800)

/* Type 2 trans records */
#define	TRANS_REC	1
#define	LOG_REC		2

#ifdef _KERNEL

typedef struct md_tps {			/* trans parent save */
	DAEMON_QUEUE
	struct mt_unit	*ps_un;
	mdi_unit_t	*ps_ui;
	buf_t		*ps_bp;
	size_t		ps_count;	/* Used for testing only. */
	kmutex_t	ps_mx;		/* protects ps_count. */
} md_tps_t;

/*
 * Log layer protos -- trans_log.c
 */
extern void		_init_ldl(void);
extern void		_fini_ldl(void);
extern void		md_ldl_round_commit(mt_unit_t *);
extern void		md_ldl_push_commit(mt_unit_t *);
extern int		md_ldl_need_commit(ml_unit_t *);
extern int		md_ldl_has_space(ml_unit_t *, mapentry_t *);
extern void		md_ldl_write(mt_unit_t *, caddr_t, offset_t,
					mapentry_t *);
extern void		md_ldl_waito(ml_unit_t *);
extern int		md_ldl_read(ml_unit_t *, caddr_t, offset_t, off_t,
					mapentry_t *);
extern void		md_ldl_sethead(ml_unit_t *, off_t, uint_t,
					struct buf *);
extern void		md_ldl_settail(ml_unit_t *, off_t, off_t,
					struct buf *);
extern void		ldl_setpwvalid(ml_unit_t *);
extern int		ldl_build_incore(ml_unit_t *, int);
extern ml_unit_t	*ldl_findlog(mddb_recid_t);
extern mddb_recid_t	ldl_create(mdkey_t, mt_unit_t *);
extern void		ldl_utadd(mt_unit_t *);
extern int		ldl_open_dev(mt_unit_t *, ml_unit_t *);
extern void		ldl_close_dev(ml_unit_t *);
extern int		ldl_snarf(void);
extern void		ldl_logscan_seterror(ml_unit_t *);
extern void		ldl_logscan_saverror(ml_unit_t *);
extern size_t		md_ldl_logscan_nbcommit(off_t);
extern int		md_ldl_logscan_read(ml_unit_t *, off_t *, size_t,
					caddr_t);
extern void		md_ldl_logscan_begin(ml_unit_t *, daddr_t);
extern void		md_ldl_logscan_end(ml_unit_t *);
extern int		md_ldl_need_roll(ml_unit_t *);
extern int		md_ldl_empty(ml_unit_t *);
extern int		ldl_pwvalid(ml_unit_t *);
extern void		ldl_waitscan(ml_unit_t *);
extern void		ldl_errorbp(set_t, buf_t *, char *);
extern void		md_ldl_seterror(ml_unit_t *);
extern int		ldl_isherror(ml_unit_t *);
extern int		ldl_iserror(ml_unit_t *);
extern int		ldl_isanyerror(ml_unit_t *);
extern void		ldl_start_scan(mt_unit_t *);
extern void		ldl_opened_trans(mt_unit_t *, int);
extern void		ldl_open_trans(mt_unit_t *, int);
extern int		ldl_logreset(mt_unit_t *, buf_t *);
extern void		ldl_close_trans(mt_unit_t *);
extern size_t		md_ldl_bufsize(ml_unit_t *);
extern void		ldl_open_underlying(mt_unit_t *);
extern void		ldl_snarf_done();
extern int		ldl_reset(mt_unit_t *, int, int);
extern void		ldl_cleanup(ml_unit_t *);

/*
 * trans driver layer -- mdtrans.c
 */
extern kmem_cache_t	*trans_child_cache;
extern void		*md_trans_zalloc(size_t);
extern void		*md_trans_zalloc_nosleep(size_t);
extern void		*md_trans_alloc(size_t);
extern void		*md_trans_alloc_nosleep(size_t);
extern void		md_trans_free(void *, size_t);
extern int		md_trans_not_wait(struct buf *cb);
extern int		md_trans_not_done(struct buf *cb);
extern int		md_trans_wait(struct buf *cb);
extern int		trans_done(struct buf *cb);
extern int		trans_done_shadow(struct buf *cb);
extern void		trans_child_init(struct buf *bp);
extern void		trans_close_all_devs(mt_unit_t *);
extern int		trans_open_all_devs(mt_unit_t *);
extern int		trans_build_incore(void *, int);
extern void		trans_commit(mt_unit_t *, int);
extern int		trans_detach(mt_unit_t *, int);
extern void		trans_attach(mt_unit_t *, int);
extern int		trans_reset(mt_unit_t *, minor_t, int, int);

/*
 * transaction ioctl -- trans_ioctl.c
 */

/* rename named service functions */
md_ren_list_svc_t	trans_rename_listkids;
md_ren_svc_t		trans_rename_check;
md_ren_roleswap_svc_t	trans_renexch_update_kids;
md_ren_roleswap_svc_t	trans_rename_update_self;
md_ren_roleswap_svc_t	trans_exchange_parent_update_to;
md_ren_roleswap_svc_t	trans_exchange_self_update_from_down;

/*
 * transaction op layer -- trans_top.c
 */
extern void	_init_md_top(void);
extern void	_fini_top(void);
extern void	top_read(struct buf *, char *, mt_unit_t *, int, void *);
extern void	md_top_read_roll(struct buf *, mt_unit_t *, ushort_t *);
extern void	top_build_incore(mt_unit_t *);
extern void	top_reset(mt_unit_t *, int, int);
extern void	top_write(struct buf *, char *, mt_unit_t *, int, void *);

/*
 * map layer -- trans_delta.c
 */
extern void		md_map_free_entries(mt_map_t *);
extern int		md_matamap_overlap(mt_map_t *, offset_t, off_t);
extern int		md_matamap_within(mt_map_t *, offset_t, off_t);
extern int		md_deltamap_need_commit(mt_map_t *);
extern void		md_deltamap_add(mt_map_t *, offset_t, off_t, delta_t,
				int (*)(), uintptr_t);
extern mapentry_t	*md_deltamap_remove(mt_map_t *, offset_t, off_t);
extern void		md_deltamap_del(mt_map_t *, offset_t, off_t);
extern void		md_deltamap_push(mt_unit_t *);
extern int		md_logmap_need_commit(mt_map_t *);
extern int		md_logmap_need_roll_async(mt_map_t *);
extern int		md_logmap_need_roll_sync(mt_map_t *);
extern int		md_logmap_need_roll(mt_map_t *);
extern void		md_logmap_start_roll(mt_unit_t *);
extern void		md_logmap_kill_roll(mt_map_t *);
extern void		md_logmap_forceroll(mt_map_t *);
extern int		md_logmap_overlap(mt_map_t *, md_dev64_t, offset_t,
				off_t);
extern void		md_logmap_remove_roll(mt_map_t *, md_dev64_t, offset_t,
				off_t);
extern int		md_logmap_next_roll(mt_map_t *, offset_t *,
				md_dev64_t *);
extern void		md_logmap_list_get(mt_map_t *, md_dev64_t, offset_t,
				off_t, mapentry_t **);
extern void		md_logmap_list_get_roll(mt_map_t *, md_dev64_t,
				offset_t, off_t, mapentry_t **);
extern void		md_logmap_list_put(mt_map_t *, mapentry_t *);
extern void		md_logmap_read_mstr(ml_unit_t *, struct buf *, int,
				void *);
extern void		md_logmap_secmap_roll(mapentry_t *, offset_t,
				ushort_t *);
extern int		logmap_read_log(ml_unit_t *, char *, offset_t, off_t,
				mapentry_t *);
extern void		md_logmap_make_space(mt_map_t *, ml_unit_t *,
				mapentry_t *);
extern void		md_logmap_add(mt_unit_t *, md_dev64_t, char *, offset_t,
				mapentry_t *);
extern void		md_logmap_add_ud(mt_unit_t *, md_dev64_t, char *,
				offset_t, mapentry_t *);
extern void		md_logmap_commit(mt_unit_t *);
extern void		md_logmap_sethead(mt_map_t *, ml_unit_t *,
				struct buf *);
extern void		md_logmap_roll_dev(mt_map_t *, ml_unit_t *ul,
				md_dev64_t);
extern void		md_logmap_roll_sud(mt_map_t *, ml_unit_t *ul,
				md_dev64_t, offset_t, off_t);
extern int		md_logmap_ud_done(struct buf *);
extern void		md_logmap_ud_wait();
extern void		md_logmap_cancel(mt_unit_t *, md_dev64_t, offset_t,
				off_t);
extern int		md_logmap_iscancel(mt_map_t *, md_dev64_t, offset_t,
				off_t);
extern void		md_logmap_logscan(mt_unit_t *, daddr_t);
extern void		map_build_incore(mt_unit_t *);
extern void		map_reset(mt_unit_t *, int, int);
extern void		_init_md_map(void);
extern void		_fini_map(void);

/*
 * scan and roll threads -- trans_thread.c
 */
extern void	md_trans_roll(ml_unit_t *);
extern void	trans_scan(mt_unit_t *);
extern void	trans_roll_prewrite(ml_unit_t *);

#endif	/* _KERNEL */

#ifdef	__cplusplus
}
#endif

#endif	/* _SYS_MD_TRANS_H */