xref: /onnv-gate/usr/src/common/lvm/md_convert.c (revision 6901:307e592cef33)

/*
 * 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.
 */

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

/*
 * md_convert.c
 *
 * As the size of a metadevice used to be stored in 32 bit signed variables,
 * there was a limit of 1 TB for the size (2^31 * 512 byte).
 * In order to be able to create larger metadevices, a 2nd set of structures
 * with wider variables for the size has been created.
 * There's one structure being shared by all types (mdc_unit_t) and one
 * for each type of metadevice (mm_unit_t, ms_unit_t, mr_unit_t, ...).
 * the wide structures are named like mdc_unit_t, mm_unit_t,..
 * The narrow structures are named like mdc_unit32_od_t, mm_unit32_od_t,...
 *
 * The wide structures are used for md's >= 1TB, the narrow structures
 * are used for md's < 1TB.
 * Once a metadevice grows from < 1TB to >= 1TB the record has to be
 * converted from a narrow one to a wide one.
 *
 * Incore (commands, libs and drivers) we only use the wide structures,
 * in order to keep it simple.
 * This means when we snarf a narrow struct, we have to convert it to a
 * wide incore instance before we can use the md.
 *
 *
 * This file contains conversion routines for the various metadevices.
 * All the conversion routines take as input two pointers to memory areas
 * and a direction. The directions specifies which memory area is the
 * source and which is the destination.
 */


#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/lvm/mdvar.h>
#ifdef _KERNEL
#include <sys/lvm/md_basic.h>
#else /* !_KERNEL */
#include <meta_basic.h>
#endif /* _KERNEL */
#include <sys/lvm/md_convert.h>


/*
 * SVM private devt expansion routine
 * INPUT:  dev  a 64 bit container holding either a 32 bit or a 64 bit device
 * OUTPUT: always an expanded 64 bit device, even if we are running in a
 *              32 bit Kernel.
 */
md_dev64_t
md_expldev(md_dev64_t dev)
{
	minor_t minor;
	major_t major = (major_t)(dev >> NBITSMINOR64) & MAXMAJ64;

	/* Here we were given a 64bit dev, return unchanged */
	if (major != (major_t)0)
		return (dev);
	/* otherwise we were given a 32 bit dev */
	major = (major_t)dev >> NBITSMINOR32 & MAXMAJ32;
	minor = (minor_t)dev & MAXMIN32;
	return (((md_dev64_t)major << NBITSMINOR64) | minor);
}

/*
 * SVM private devt compact routine
 * INPUT:  dev  a 64 bit container holding either a 32 bit or a 64 bit device
 * OUTPUT: always a compacted 32 bit device, even if we are running in a
 *              64 bit Kernel.
 */
dev32_t
md_cmpldev(md_dev64_t dev)
{
	minor_t minor;
	major_t major = (major_t)(dev >> NBITSMINOR64) & MAXMAJ64;

	/* Here we were given a 32bit dev, return unchanged */
	if (major == 0) {
		return ((dev32_t)dev);
	}
	/* otherwise we were given a 64 bit dev */
	minor = (minor_t)dev & MAXMIN32;
	return (((dev32_t)major << NBITSMINOR32) | minor);
}


/*
 * given a small stripe unit, compute the size of an appropriate
 * big stripe unit.
 * if first_comp_only is set just return the offset of the first component
 * in the new big unit.
 *
 * The function:
 * usr/src/lib/lvm/libmeta/common/meta_statconcise.c:get_stripe_req_size()
 * contains code derived from this function and thus if any changes are made to
 * this function get_stripe_req_size() should be evaluated to determine whether
 * or not code changes will also  be necessary there.
 *
 */
size_t
get_big_stripe_req_size(ms_unit32_od_t *un, int first_comp_only)
{
	struct ms_row32_od *mdr;
	uint_t row;
	uint_t ncomps = 0;
	size_t mdsize = 0;
	size_t first_comp = 0;


	/* Compute the offset of the first component */
	first_comp = sizeof (ms_unit_t) +
	    sizeof (struct ms_row) * (un->un_nrows - 1);
	first_comp = roundup(first_comp, sizeof (long long));
	if (first_comp_only == FIRST_COMP_OFFSET)
		return (first_comp);

	/*
	 * Requestor wants to have the total size, add the sizes of
	 * all components
	 */
	mdr = &un->un_row[0];
	for (row = 0; (row < un->un_nrows); row++)
		ncomps += mdr[row].un_ncomp;
	mdsize = first_comp + sizeof (ms_comp_t) * ncomps;
	return (mdsize);
}

/*
 * given a big stripe unit, compute the size of an appropriate
 * small stripe unit.
 * if first_comp_only is set just return the offset of the first component
 * in the new small unit.
 */
size_t
get_small_stripe_req_size(ms_unit_t *un, int first_comp_only)
{
	struct ms_row *mdr;
	uint_t row;
	uint_t ncomps = 0;
	size_t mdsize;
	size_t first_comp;

	/* Compute the size of the new small ms_unit */
	first_comp = sizeof (ms_unit32_od_t) +
	    sizeof (struct ms_row32_od) * (un->un_nrows - 1);
	first_comp = roundup(first_comp, sizeof (long long));
	if (first_comp_only == FIRST_COMP_OFFSET)
		return (first_comp);

	/*
	 * Requestor wants to have the total size, add the sizes of
	 * all components
	 */
	mdr = &un->un_row[0];
	for (row = 0; (row < un->un_nrows); row++)
		ncomps += mdr[row].un_ncomp;
	mdsize = first_comp + sizeof (ms_comp32_od_t) * ncomps;
	return (mdsize);
}


/*
 * stripe_convert(small, big, dir)
 *
 * Parameters:
 *	small is the address of a ms_unit32_od_t structure
 *	big   is the address of a ms_unit_t structure
 *	dir   is either BIG2SMALL or SMALL2BIG
 * Return value is void
 *
 * what it does:
 * 	if dir is BIG2SMALL, convert from big to small (updating old records)
 * 	if dir is SMALL2BIG, convert from small to big (snarfing old records)
 *
 * Caveat emptor: big and small must be well allocated memory areas.
 */

void
stripe_convert(caddr_t small, caddr_t big, int direction)
{
	/*LINTED*/
	ms_unit32_od_t *small_un = (ms_unit32_od_t *)small;
	/*LINTED*/
	ms_unit_t *big_un = (ms_unit_t *)big;

	struct ms_row32_od	*small_mdr;
	struct ms_row		*big_mdr;
	uint_t			row, comp, ncomps = 0;
	ms_comp_t		*big_mdcomp;
	ms_comp32_od_t		*small_mdcomp;

	if (direction == BIG_2_SMALL) {
		MDC_UNIT_BIG2SMALL(big_un, small_un);

		small_un->un_hsp_id = big_un->un_hsp_id;
		small_un->un_nrows  = big_un->un_nrows;
		small_un->c.un_size =
		    get_small_stripe_req_size(big_un, COMPLETE_STRUCTURE);
		small_un->un_ocomp  =
		    get_small_stripe_req_size(big_un, FIRST_COMP_OFFSET);

		/* walk through all rows */
		big_mdr   = &big_un->un_row[0];
		small_mdr = &small_un->un_row[0];

		for (row = 0; (row < big_un->un_nrows); row++) {
			ncomps += big_mdr[row].un_ncomp;
			MSROW_BIG2SMALL((&(big_mdr[row])), (&(small_mdr[row])));
		}

		/* Now copy the components */
		big_mdcomp = (ms_comp_t *)(void *)&((char *)big_un)
		    [big_un->un_ocomp];
		small_mdcomp = (ms_comp32_od_t *)(void *)&((char *)small_un)
		    [small_un->un_ocomp];
		for (comp = 0; (comp < ncomps); ++comp) {
			ms_comp_t	*big_mdcp   = &big_mdcomp[comp];
			ms_comp32_od_t	*small_mdcp = &small_mdcomp[comp];

			MSCOMP_BIG2SMALL(big_mdcp, small_mdcp);

		}
	}

	if (direction == SMALL_2_BIG) {
		MDC_UNIT_SMALL2BIG(small_un, big_un);

		big_un->un_hsp_id = small_un->un_hsp_id;
		big_un->un_nrows  = small_un->un_nrows;
		big_un->c.un_size =
		    get_big_stripe_req_size(small_un, COMPLETE_STRUCTURE);
		big_un->un_ocomp  =
		    get_big_stripe_req_size(small_un, FIRST_COMP_OFFSET);


		/* walk through all rows */
		small_mdr = &small_un->un_row[0];
		big_mdr   = &big_un->un_row[0];

		for (row = 0; (row < small_un->un_nrows); row++) {
			ncomps += small_mdr[row].un_ncomp;
			MSROW_SMALL2BIG((&(small_mdr[row])), (&(big_mdr[row])));
		}
		/* Now copy the components */
		big_mdcomp = (ms_comp_t *)(void *)&((char *)big_un)
		    [big_un->un_ocomp];
		small_mdcomp = (ms_comp32_od_t *)(void *)&((char *)small_un)
		    [small_un->un_ocomp];
		for (comp = 0; (comp < ncomps); ++comp) {
			ms_comp_t *big_mdcp = &big_mdcomp[comp];
			ms_comp32_od_t *small_mdcp = &small_mdcomp[comp];

			MSCOMP_SMALL2BIG(small_mdcp, big_mdcp);

		}
	}
}

/*
 * mirror_convert(small, big, dir)
 *
 * Parameters:
 *	small is the address of a mm_unit32_od_t structure
 *	big   is the address of a mm_unit_t structure
 *	dir   is either BIG2SMALL or SMALL2BIG
 * Return value is void
 *
 * what it does:
 * 	if dir is BIG2SMALL, convert from big to small (updating old records)
 * 	if dir is SMALL2BIG, convert from small to big (snarfing old records)
 *
 * Caveat emptor: big and small must be well allocated memory areas.
 */
void
mirror_convert(caddr_t small, caddr_t big, int direction)
{
	/*LINTED*/
	mm_unit32_od_t *small_un = (mm_unit32_od_t *)small;
	/*LINTED*/
	mm_unit_t *big_un = (mm_unit_t *)big;
	int i;


	if (direction == BIG_2_SMALL) {
		MDC_UNIT_BIG2SMALL(big_un, small_un);

		small_un->c.un_size =
		    roundup(sizeof (mm_unit32_od_t), sizeof (long long));
		small_un->un_last_read = big_un->un_last_read;
		small_un->un_changecnt = big_un->un_changecnt;
		small_un->un_nsm = big_un->un_nsm;
		for (i = 0; i < NMIRROR; i++) {
			MMSM_BIG2SMALL((&(big_un->un_sm[i])),
			    (&(small_un->un_sm[i])));
		}
		small_un->un_overlap_tree_flag = big_un->un_overlap_tree_flag;
		small_un->un_read_option = big_un->un_read_option;
		small_un->un_write_option = big_un->un_write_option;
		small_un->un_pass_num = big_un->un_pass_num;
		small_un->un_rrd_blksize = big_un->un_rrd_blksize;
		small_un->un_rrd_num = big_un->un_rrd_num;
		small_un->un_rr_dirty_recid = big_un->un_rr_dirty_recid;
		small_un->un_rs_copysize = big_un->un_rs_copysize;
		small_un->un_rs_dests = big_un->un_rs_dests;
		small_un->un_rs_resync_done =
		    (daddr32_t)big_un->un_rs_resync_done;
		small_un->un_rs_resync_2_do =
		    (daddr32_t)big_un->un_rs_resync_2_do;
		small_un->un_rs_dropped_lock = big_un->un_rs_dropped_lock;
		small_un->un_rs_type = big_un->un_rs_type;
	}

	if (direction == SMALL_2_BIG) {
		MDC_UNIT_SMALL2BIG(small_un, big_un);
		big_un->c.un_size =
		    roundup(sizeof (mm_unit_t), sizeof (long long));
		big_un->un_last_read = small_un->un_last_read;
		big_un->un_changecnt = small_un->un_changecnt;
		big_un->un_nsm = small_un->un_nsm;


		for (i = 0; i < NMIRROR; i++) {
			MMSM_SMALL2BIG((&(small_un->un_sm[i])),
			    (&(big_un->un_sm[i])));
		}


		/* Now back to the simple things again */
		big_un->un_overlap_tree_flag = small_un->un_overlap_tree_flag;
		big_un->un_read_option = small_un->un_read_option;
		big_un->un_write_option = small_un->un_write_option;
		big_un->un_pass_num = small_un->un_pass_num;
		big_un->un_rrd_blksize = small_un->un_rrd_blksize;
		big_un->un_rrd_num = small_un->un_rrd_num;
		big_un->un_rr_dirty_recid = small_un->un_rr_dirty_recid;
		big_un->un_rs_copysize = small_un->un_rs_copysize;
		big_un->un_rs_dests = small_un->un_rs_dests;
		big_un->un_rs_resync_done =
		    (diskaddr_t)small_un->un_rs_resync_done;
		big_un->un_rs_resync_2_do =
		    (diskaddr_t)small_un->un_rs_resync_2_do;
		big_un->un_rs_dropped_lock = small_un->un_rs_dropped_lock;
		big_un->un_rs_type = small_un->un_rs_type;
	}
}

/*
 * raid_convert(small, big, dir)
 *
 * Parameters:
 *	small is the address of a mr_unit32_od_t structure
 *	big   is the address of a mr_unit_t structure
 *	dir   is either BIG2SMALL or SMALL2BIG
 * Return value is void
 *
 * what it does:
 * 	if dir is BIG2SMALL, convert from big to small (updating old records)
 * 	if dir is SMALL2BIG, convert from small to big (snarfing old records)
 *
 * Caveat emptor: big and small must be well allocated memory areas.
 */
void
raid_convert(caddr_t small, caddr_t big, int direction)

{
	/*LINTED*/
	mr_unit32_od_t *small_un = (mr_unit32_od_t *)small;
	/*LINTED*/
	mr_unit_t *big_un = (mr_unit_t *)big;

	int i;
	uint_t	ncol;

	if (direction == BIG_2_SMALL) {
		MRUNIT_BIG2SMALL(big_un, small_un);

		ncol = small_un->un_totalcolumncnt;
		small_un->c.un_size = sizeof (mr_unit32_od_t);
		small_un->c.un_size += (ncol - 1) * sizeof (mr_column32_od_t);
		for (i = 0; i < ncol; i++) {
			MRCOL_BIG2SMALL((&(big_un->un_column[i])),
			    (&(small_un->un_column[i])));
		}
	}

	if (direction == SMALL_2_BIG) {
		MRUNIT_SMALL2BIG(small_un, big_un);

		ncol = big_un->un_totalcolumncnt;
		big_un->c.un_size = sizeof (mr_unit_t);
		big_un->c.un_size += (ncol - 1) * sizeof (mr_column_t);
		for (i = 0; i < ncol; i++) {
			MRCOL_SMALL2BIG((&(small_un->un_column[i])),
			    (&(big_un->un_column[i])));
		}
	}
}





/*
 * softpart_convert(small, big, dir)
 *
 * Parameters:
 *	small is the address of a mp_unit32_od_t structure
 *	big   is the address of a mp_unit_t structure
 *	dir   is either BIG2SMALL or SMALL2BIG
 * Return value is void
 *
 * what it does:
 * 	if dir is BIG2SMALL, convert from big to small (updating old records)
 * 	if dir is SMALL2BIG, convert from small to big (snarfing old records)
 *
 * Caveat emptor: big and small must be well allocated memory areas.
 */
void
softpart_convert(caddr_t small, caddr_t big, int direction)

{
	/*LINTED*/
	mp_unit32_od_t *small_un = (mp_unit32_od_t *)small;
	/*LINTED*/
	mp_unit_t *big_un = (mp_unit_t *)big;

	if (direction == BIG_2_SMALL) {
		MPUNIT_BIG2SMALL(big_un, small_un);
		/*
		 * Note that there isn't a mp_ext32_od_t, it's right to use
		 * mp_ext_t here, too.
		 */
		small_un->c.un_size = sizeof (mp_unit32_od_t) +
			(small_un->un_numexts - 1) * sizeof (mp_ext_t);
	}

	if (direction == SMALL_2_BIG) {
		MPUNIT_SMALL2BIG(small_un, big_un);
		big_un->c.un_size = sizeof (mp_unit_t) +
			(big_un->un_numexts - 1) * sizeof (mp_ext_t);
	}
}


/*
 * trans_master_convert(smallp, bigp, dir)
 *
 * Parameters:
 *	smallp is the address of a mt_unit32_od_t structure
 *	bigp   is the address of a mt_unit_t structure
 *	dir   is either BIG2SMALL or SMALL2BIG
 * Return value is void
 *
 * what it does:
 * 	if dir is BIG2SMALL, convert from big to small (updating old records)
 * 	if dir is SMALL2BIG, convert from small to big (snarfing old records)
 *
 * Caveat emptor: bigp and smallp must be well allocated memory areas.
 */
void
trans_master_convert(caddr_t smallp, caddr_t bigp, int direction)
{
	/*LINTED*/
	mt_unit32_od_t *small = (mt_unit32_od_t *)smallp;
	/*LINTED*/
	mt_unit_t *big = (mt_unit_t *)bigp;

	if (direction == SMALL_2_BIG) {
		MDC_UNIT_SMALL2BIG(small, big);
		big->c.un_size =
		    roundup(sizeof (mt_unit_t), sizeof (long long));
		big->un_flags		= small->un_flags;
		big->un_m_key		= small->un_m_key;
		big->un_m_dev		= md_expldev(small->un_m_dev);
		big->un_l_key		= small->un_l_key;
		big->un_l_dev		= md_expldev(small->un_l_dev);
		big->un_l_sblk		= small->un_l_sblk;
		big->un_l_pwsblk	= small->un_l_pwsblk;
		big->un_l_nblks		= small->un_l_nblks;
		big->un_l_tblks		= small->un_l_tblks;
		big->un_l_head		= small->un_l_head;
		big->un_l_tail		= small->un_l_tail;
		big->un_l_resv		= small->un_l_resv;
		big->un_l_maxresv	= small->un_l_maxresv;
		big->un_l_recid		= small->un_l_recid;
		big->un_l_error		= small->un_l_error;
		big->un_s_dev		= md_expldev(small->un_s_dev);
		big->un_debug		= small->un_debug;
		big->un_dev		= md_expldev(small->un_dev);
		big->un_logreset	= small->un_logreset;
		big->un_l_maxtransfer	= small->un_l_maxtransfer;
		big->un_timestamp.tv_sec = small->un_timestamp.tv_sec;
		big->un_timestamp.tv_usec = small->un_timestamp.tv_usec;
		big->un_l_timestamp.tv_sec = small->un_l_timestamp.tv_sec;
		big->un_l_timestamp.tv_usec = small->un_l_timestamp.tv_usec;
	}
	if (direction == BIG_2_SMALL) {
		MDC_UNIT_BIG2SMALL(big, small);
		small->c.un_size =
		    roundup(sizeof (mt_unit32_od_t), sizeof (long long));
		small->un_flags		= big->un_flags;
		small->un_m_key		= big->un_m_key;
		small->un_m_dev		= md_cmpldev(big->un_m_dev);
		small->un_l_key		= big->un_l_key;
		small->un_l_dev		= md_cmpldev(big->un_l_dev);
		small->un_l_sblk	= big->un_l_sblk;
		small->un_l_pwsblk	= big->un_l_pwsblk;
		small->un_l_nblks	= big->un_l_nblks;
		small->un_l_tblks	= big->un_l_tblks;
		small->un_l_head	= big->un_l_head;
		small->un_l_tail	= big->un_l_tail;
		small->un_l_resv	= big->un_l_resv;
		small->un_l_maxresv	= big->un_l_maxresv;
		small->un_l_maxtransfer	= big->un_l_maxtransfer;
		small->un_l_recid	= big->un_l_recid;
		small->un_l_error	= big->un_l_error;
		small->un_s_dev		= md_cmpldev(big->un_s_dev);
		small->un_debug		= big->un_debug;
		small->un_dev		= md_cmpldev(big->un_dev);
		small->un_logreset	= big->un_logreset;
		small->un_timestamp.tv_sec = big->un_timestamp.tv_sec;
		small->un_timestamp.tv_usec = big->un_timestamp.tv_usec;
		small->un_l_timestamp.tv_sec = big->un_l_timestamp.tv_sec;
		small->un_l_timestamp.tv_usec = big->un_l_timestamp.tv_usec;
	}

}


/*
 * trans_log_convert(smallp, bigp, dir)
 *
 * Parameters:
 *	smallp is the address of a ml_unit32_od_t structure
 *	bigp   is the address of a ml_unit_t structure
 *	dir   is either BIG2SMALL or SMALL2BIG
 * Return value is void
 *
 * what it does:
 * 	if dir is BIG2SMALL, convert from big to small (updating old records)
 * 	if dir is SMALL2BIG, convert from small to big (snarfing old records)
 *
 * Caveat emptor: bigp and smallp must be well allocated memory areas.
 */
void
trans_log_convert(caddr_t smallp, caddr_t bigp, int direction)
{
	/*LINTED*/
	ml_unit32_od_t *small = (ml_unit32_od_t *)smallp;
	/*LINTED*/
	ml_unit_t *big = (ml_unit_t *)bigp;

	if (direction == SMALL_2_BIG) {
		big->un_revision	= small->un_revision;
		big->un_recid		= small->un_recid;
		big->un_key		= small->un_key;
		big->un_dev		= md_expldev(small->un_dev);
		big->un_opencnt		= small->un_opencnt;
		big->un_transcnt	= small->un_transcnt;
		big->un_head_lof	= small->un_head_lof;
		big->un_head_ident	= small->un_head_ident;
		big->un_tail_lof	= small->un_tail_lof;
		big->un_tail_ident	= small->un_tail_ident;
		big->un_bol_lof		= small->un_bol_lof;
		big->un_eol_lof		= small->un_eol_lof;
		big->un_nblks		= small->un_nblks;
		big->un_tblks		= small->un_tblks;
		big->un_maxtransfer	= small->un_maxtransfer;
		big->un_status		= small->un_status;
		big->un_maxresv		= small->un_maxresv;
		big->un_pwsblk		= small->un_pwsblk;
		big->un_devbsize	= small->un_devbsize;
		big->un_resv		= small->un_resv;
		big->un_resv_wantin	= small->un_resv_wantin;
		big->un_error		= small->un_error;
		big->un_tid		= small->un_tid;
		big->un_head_tid	= small->un_head_tid;
		big->un_timestamp.tv_sec = small->un_timestamp.tv_sec;
		big->un_timestamp.tv_usec = small->un_timestamp.tv_usec;
	}
	if (direction == BIG_2_SMALL) {
		small->un_revision	= big->un_revision;
		small->un_recid		= big->un_recid;
		small->un_key		= big->un_key;
		small->un_dev		= md_cmpldev(big->un_dev);
		small->un_opencnt	= big->un_opencnt;
		small->un_transcnt	= big->un_transcnt;
		small->un_head_lof	= big->un_head_lof;
		small->un_head_ident	= big->un_head_ident;
		small->un_tail_lof	= big->un_tail_lof;
		small->un_tail_ident	= big->un_tail_ident;
		small->un_bol_lof	= big->un_bol_lof;
		small->un_eol_lof	= big->un_eol_lof;
		small->un_nblks		= big->un_nblks;
		small->un_tblks		= big->un_tblks;
		small->un_maxtransfer	= big->un_maxtransfer;
		small->un_status	= big->un_status;
		small->un_maxresv	= big->un_maxresv;
		small->un_pwsblk	= big->un_pwsblk;
		small->un_devbsize	= big->un_devbsize;
		small->un_resv		= big->un_resv;
		small->un_resv_wantin	= big->un_resv_wantin;
		small->un_error		= big->un_error;
		small->un_tid		= big->un_tid;
		small->un_head_tid	= big->un_head_tid;
		small->un_timestamp.tv_sec = big->un_timestamp.tv_sec;
		small->un_timestamp.tv_usec = big->un_timestamp.tv_usec;
	}
}

/*
 * hs_convert(small, big, dir)
 *
 * Parameters:
 *	small is the address of a hot_spare32_od_t structure
 *	big   is the address of a hot_spare_t structure
 *	dir   is either BIG2SMALL or SMALL2BIG
 * Return value is void
 *
 * what it does:
 * 	if dir is BIG2SMALL, convert from big to small (updating old records)
 * 	if dir is SMALL2BIG, convert from small to big (snarfing old records)
 *
 * Caveat emptor: big and small must be well allocated memory areas.
 */
void
hs_convert(caddr_t small, caddr_t big, int direction)

{
	/*LINTED*/
	hot_spare32_od_t *small_un = (hot_spare32_od_t *)small;
	/*LINTED*/
	hot_spare_t *big_un = (hot_spare_t *)big;

	if (direction == BIG_2_SMALL) {
		MHS_BIG2SMALL(big_un, small_un);
	}

	if (direction == SMALL_2_BIG) {
		MHS_SMALL2BIG(small_un, big_un);
	}
}