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