3909 "zfs send -D" does not work

[illumos-gate.git] / usr / src / common / lvm / md_convert.c

/*
 * 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);
        }
}