/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * Copyright by The HDF Group.                                               *

 * All rights reserved.                                                      *

 *                                                                           *

 * This file is part of HDF5.  The full HDF5 copyright notice, including     *

 * terms governing use, modification, and redistribution, is contained in    *

 * the LICENSE file, which can be found at the root of the source code       *

 * distribution tree, or in https://www.hdfgroup.org/licenses.               *

 * If you do not have access to either file, you may request a copy from     *

 * help@hdfgroup.org.                                                        *

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*

 * Purpose:     Compact dataset I/O functions.  These routines are similar

 *              H5D_contig_* and H5D_chunk_*.

 */

/****************/

/* Module Setup */

/****************/

#include "H5Dmodule.h" /* This source code file is part of the H5D module */

/***********/

/* Headers */

/***********/

#include "H5private.h"   /* Generic Functions     */

#include "H5Dpkg.h"      /* Dataset functions     */

#include "H5Eprivate.h"  /* Error handling        */

#include "H5Fprivate.h"  /* Files       */

#include "H5FDprivate.h" /* File drivers        */

#include "H5FLprivate.h" /* Free Lists                           */

#include "H5Iprivate.h"  /* IDs           */

#include "H5MMprivate.h" /* Memory management     */

#include "H5Oprivate.h"  /* Object headers        */

#include "H5VMprivate.h" /* Vector and array functions    */

/****************/

/* Local Macros */

/****************/

/******************/

/* Local Typedefs */

/******************/

/* Callback info for I/O operation when file driver

 * wishes to do its own memory management

 */

typedef struct H5D_compact_iovv_memmanage_ud_t {

    H5F_shared_t *f_sh;   /* Shared file for dataset */

    void         *dstbuf; /* Pointer to buffer to be read into/written into */

    const void   *srcbuf; /* Pointer to buffer to be read from/written from */

} H5D_compact_iovv_memmanage_ud_t;

/********************/

/* Local Prototypes */

/********************/

/* Layout operation callbacks */

static herr_t  H5D__compact_construct(H5F_t *f, H5D_t *dset);

static herr_t  H5D__compact_init(H5F_t *f, H5D_t *dset, hid_t dapl_id, bool open_op);

static bool    H5D__compact_is_space_alloc(const H5O_storage_t *storage);

static herr_t  H5D__compact_io_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo);

static herr_t  H5D__compact_iovv_memmanage_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata);

static ssize_t H5D__compact_readvv(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_info,

                                   size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[],

                                   hsize_t dset_offset_arr[], size_t mem_max_nseq, size_t *mem_curr_seq,

                                   size_t mem_size_arr[], hsize_t mem_offset_arr[]);

static ssize_t H5D__compact_writevv(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_info,

                                    size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[],

                                    hsize_t dset_offset_arr[], size_t mem_max_nseq, size_t *mem_curr_seq,

                                    size_t mem_size_arr[], hsize_t mem_offset_arr[]);

static herr_t  H5D__compact_flush(H5D_t *dset);

static herr_t  H5D__compact_dest(H5D_t *dset);

/*********************/

/* Package Variables */

/*********************/

/* Compact storage layout I/O ops */

const H5D_layout_ops_t H5D_LOPS_COMPACT[1] = {{

    H5D__compact_construct,      /* construct */

    H5D__compact_init,           /* init */

    H5D__compact_is_space_alloc, /* is_space_alloc */

    NULL,                        /* is_data_cached */

    H5D__compact_io_init,        /* io_init */

    NULL,                        /* mdio_init */

    H5D__contig_read,            /* ser_read */

    H5D__contig_write,           /* ser_write */

    H5D__compact_readvv,         /* readvv */

    H5D__compact_writevv,        /* writevv */

    H5D__compact_flush,          /* flush */

    NULL,                        /* io_term */

    H5D__compact_dest            /* dest */

}};

/*******************/

/* Local Variables */

/*******************/

/* Declare extern the free list to manage blocks of type conversion data */

H5FL_BLK_EXTERN(type_conv);

/*-------------------------------------------------------------------------

 * Function:  H5D__compact_fill

 *

 * Purpose: Write fill values to a compactly stored dataset.

 *

 * Return:  Non-negative on success/Negative on failure

 *

 *-------------------------------------------------------------------------

 */

herr_t

H5D__compact_fill(const H5D_t *dset)

{

    H5D_fill_buf_info_t fb_info;                /* Dataset's fill buffer info */

    bool                fb_info_init = false;   /* Whether the fill value buffer has been initialized */

    herr_t              ret_value    = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE

    /* Check args */

    assert(dset && H5D_COMPACT == dset->shared->layout.type);

    assert(dset->shared->layout.storage.u.compact.buf);

    assert(dset->shared->type);

    assert(dset->shared->space);

    /* Initialize the fill value buffer */

    /* (use the compact dataset storage buffer as the fill value buffer) */

    if (H5D__fill_init(&fb_info, dset->shared->layout.storage.u.compact.buf, NULL, NULL, NULL, NULL,

                       &dset->shared->dcpl_cache.fill, dset->shared->type, (size_t)0,

                       dset->shared->layout.storage.u.compact.size) < 0)

        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't initialize fill buffer info");

    fb_info_init = true;

    /* Check for VL datatype & non-default fill value */

    if (fb_info.has_vlen_fill_type)

        /* Fill the buffer with VL datatype fill values */

        if (H5D__fill_refill_vl(&fb_info, fb_info.elmts_per_buf) < 0)

            HGOTO_ERROR(H5E_DATASET, H5E_CANTCONVERT, FAIL, "can't refill fill value buffer");

done:

    /* Release the fill buffer info, if it's been initialized */

    if (fb_info_init && H5D__fill_term(&fb_info) < 0)

        HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");

    FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__compact_fill() */

/*-------------------------------------------------------------------------

 * Function:    H5D__compact_construct

 *

 * Purpose:     Constructs new compact layout information for dataset and

 *              upgrades layout version if appropriate

 *

 * Return:      Non-negative on success/Negative on failure

 *

 *-------------------------------------------------------------------------

 */

static herr_t

H5D__compact_construct(H5F_t *f, H5D_t *dset)

{

    hssize_t stmp_size;           /* Temporary holder for raw data size */

    hsize_t  tmp_size;            /* Temporary holder for raw data size */

    hsize_t  max_comp_data_size;  /* Max. allowed size of compact data */

    unsigned version;             /* Message version */

    unsigned u;                   /* Local index variable */

    herr_t   ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE

    /* Sanity checks */

    assert(f);

    assert(dset);

    assert(dset->shared);

    /* Check for invalid dataset dimensions */

    for (u = 0; u < dset->shared->ndims; u++)

        if (dset->shared->max_dims[u] > dset->shared->curr_dims[u])

            HGOTO_ERROR(H5E_DATASET, H5E_UNSUPPORTED, FAIL, "extendible compact dataset not allowed");

    /*

     * Compact dataset is stored in dataset object header message of

     * layout.

     */

    stmp_size = H5S_GET_EXTENT_NPOINTS(dset->shared->space);

    assert(stmp_size >= 0);

    tmp_size = H5T_get_size(dset->shared->type);

    assert(tmp_size > 0);

    tmp_size = tmp_size * (hsize_t)stmp_size;

    H5_CHECKED_ASSIGN(dset->shared->layout.storage.u.compact.size, size_t, tmp_size, hssize_t);

    /* Verify data size is smaller than maximum header message size

     * (64KB) minus other layout message fields.

     */

    max_comp_data_size = H5O_MESG_MAX_SIZE - H5D__layout_meta_size(f, &(dset->shared->layout), false);

    if (dset->shared->layout.storage.u.compact.size > max_comp_data_size)

        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL,

                    "compact dataset size is bigger than header message maximum size");

    /* If the layout is below version 3, upgrade to version 3 if allowed. Do not upgrade past version 3 since

     * there is no benefit. */

    if (dset->shared->layout.version < H5O_LAYOUT_VERSION_3) {

        version = MAX(dset->shared->layout.version,

                      MIN(H5O_layout_ver_bounds[H5F_LOW_BOUND(f)], H5O_LAYOUT_VERSION_3));

        /* Version bounds check */

        if (version > H5O_layout_ver_bounds[H5F_HIGH_BOUND(f)])

            HGOTO_ERROR(H5E_DATASET, H5E_BADRANGE, FAIL, "layout version out of bounds");

        dset->shared->layout.version = version;

    }

done:

    FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__compact_construct() */

/*-------------------------------------------------------------------------

 * Function:  H5D__compact_init

 *

 * Purpose: Initialize the info for a compact dataset.  This is

 *    called when the dataset is initialized.

 *

 * Return:  Non-negative on success/Negative on failure

 *

 *-------------------------------------------------------------------------

 */

static herr_t

H5D__compact_init(H5F_t H5_ATTR_UNUSED *f, H5D_t *dset, hid_t H5_ATTR_UNUSED dapl_id,

                  bool H5_ATTR_UNUSED open_op)

{

    hssize_t snelmts;             /* Temporary holder for number of elements in dataspace */

    hsize_t  nelmts;              /* Number of elements in dataspace */

    size_t   dt_size;             /* Size of datatype */

    hsize_t  data_size;           /* Dataset size, in bytes */

    herr_t   ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE

    /* Sanity check */

    assert(dset);

    assert(H5D_COMPACT == dset->shared->layout.storage.type);

    /*

     * Now that we've read the dataset's datatype, dataspace and

     * layout information, perform a quick check for compact datasets

     * to ensure that the size of the internal buffer that was

     * allocated for the dataset's raw data matches the size of

     * the data. A corrupted file can cause a mismatch between the

     * two, which might result in buffer overflows during future

     * I/O to the dataset.

     */

    if (0 == (dt_size = H5T_GET_SIZE(dset->shared->type)))

        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get datatype size");

    if ((snelmts = H5S_GET_EXTENT_NPOINTS(dset->shared->space)) < 0)

        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get number of elements in dataset's dataspace");

    nelmts = (hsize_t)snelmts;

    /* Compute the size of the dataset's contiguous storage */

    data_size = nelmts * dt_size;

    /* Check for overflow during multiplication */

    if (nelmts != (data_size / dt_size))

        HGOTO_ERROR(H5E_DATASET, H5E_OVERFLOW, FAIL, "size of dataset's storage overflowed");

    /* Check for mismatch */

    if (dset->shared->layout.storage.u.compact.size != data_size)

        HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL,

                    "bad value from dataset header - size of compact dataset's data buffer doesn't match "

                    "size of dataset data");

done:

    FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__compact_init() */

/*-------------------------------------------------------------------------

 * Function:  H5D__compact_is_space_alloc

 *

 * Purpose: Query if space is allocated for layout

 *

 * Return:  Non-negative on success/Negative on failure

 *

 *-------------------------------------------------------------------------

 */

static bool

H5D__compact_is_space_alloc(const H5O_storage_t H5_ATTR_UNUSED *storage)

{

    FUNC_ENTER_PACKAGE_NOERR

    /* Sanity checks */

    assert(storage);

    /* Compact storage is currently always allocated */

    FUNC_LEAVE_NOAPI(true)

} /* end H5D__compact_is_space_alloc() */

/*-------------------------------------------------------------------------

 * Function:  H5D__compact_io_init

 *

 * Purpose: Performs initialization before any sort of I/O on the raw data

 *

 * Return:  Non-negative on success/Negative on failure

 *

 *-------------------------------------------------------------------------

 */

static herr_t

H5D__compact_io_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo)

{

    FUNC_ENTER_PACKAGE_NOERR

    dinfo->store->compact.buf               = dinfo->dset->shared->layout.storage.u.compact.buf;

    dinfo->store->compact.dirty             = &dinfo->dset->shared->layout.storage.u.compact.dirty;

    dinfo->layout_io_info.contig_piece_info = NULL;

    /* Disable selection I/O */

    io_info->use_select_io = H5D_SELECTION_IO_MODE_OFF;

    io_info->no_selection_io_cause |= H5D_SEL_IO_NOT_CONTIGUOUS_OR_CHUNKED_DATASET;

    FUNC_LEAVE_NOAPI(SUCCEED)

} /* end H5D__compact_io_init() */

/*-------------------------------------------------------------------------

 * Function:    H5D__compact_iovv_memmanage_cb

 *

 * Purpose:     Callback operator for H5D__compact_readvv()/_writevv() to

 *              send a memory copy request to the underlying file driver.

 *

 * Return:      Non-negative on success/Negative on failure

 *

 *-------------------------------------------------------------------------

 */

static herr_t

H5D__compact_iovv_memmanage_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata)

{

    H5D_compact_iovv_memmanage_ud_t *udata = (H5D_compact_iovv_memmanage_ud_t *)_udata;

    H5FD_ctl_memcpy_args_t           op_args;

    uint64_t                         op_flags;

    H5FD_t                          *file_handle = NULL;

    herr_t                           ret_value   = SUCCEED;

    FUNC_ENTER_PACKAGE

    /* Retrieve pointer to file driver structure for ctl call */

    if (H5F_shared_get_file_driver(udata->f_sh, &file_handle) < 0)

        HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL, "can't get file handle");

    /* Setup operation flags and arguments */

    op_flags = H5FD_CTL_ROUTE_TO_TERMINAL_VFD_FLAG | H5FD_CTL_FAIL_IF_UNKNOWN_FLAG;

    op_args.dstbuf  = udata->dstbuf;

    op_args.dst_off = dst_off;

    op_args.srcbuf  = udata->srcbuf;

    op_args.src_off = src_off;

    op_args.len     = len;

    /* Make request to file driver */

    if (H5FD_ctl(file_handle, H5FD_CTL_MEM_COPY, op_flags, &op_args, NULL) < 0)

        HGOTO_ERROR(H5E_IO, H5E_FCNTL, FAIL, "VFD memcpy request failed");

done:

    FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__compact_iovv_memmanage_cb() */

/*-------------------------------------------------------------------------

 * Function:    H5D__compact_readvv

 *

 * Purpose:     Reads some data vectors from a dataset into a buffer.

 *              The data is in compact dataset.  The address is relative

 *              to the beginning address of the dataset.  The offsets and

 *              sequence lengths are in bytes.

 *

 * Return:      Non-negative on success/Negative on failure

 *

 * Notes:

 *              Offsets in the sequences must be monotonically increasing

 *

 *-------------------------------------------------------------------------

 */

static ssize_t

H5D__compact_readvv(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_info, size_t dset_max_nseq,

                    size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],

                    size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[],

                    hsize_t mem_offset_arr[])

{

    ssize_t ret_value = -1; /* Return value */

    FUNC_ENTER_PACKAGE

    assert(io_info);

    assert(dset_info);

    /* Check if file driver wishes to do its own memory management */

    if (H5F_SHARED_HAS_FEATURE(io_info->f_sh, H5FD_FEAT_MEMMANAGE)) {

        H5D_compact_iovv_memmanage_ud_t udata;

        /* Set up udata for memory copy operation */

        udata.f_sh   = io_info->f_sh;

        udata.dstbuf = dset_info->buf.vp;

        udata.srcbuf = dset_info->store->compact.buf;

        /* Request that file driver does the memory copy */

        if ((ret_value = H5VM_opvv(mem_max_nseq, mem_curr_seq, mem_size_arr, mem_offset_arr, dset_max_nseq,

                                   dset_curr_seq, dset_size_arr, dset_offset_arr,

                                   H5D__compact_iovv_memmanage_cb, &udata)) < 0)

            HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");

    }

    else {

        /* Use the vectorized memory copy routine to do actual work */

        if ((ret_value = H5VM_memcpyvv(dset_info->buf.vp, mem_max_nseq, mem_curr_seq, mem_size_arr,

                                       mem_offset_arr, dset_info->store->compact.buf, dset_max_nseq,

                                       dset_curr_seq, dset_size_arr, dset_offset_arr)) < 0)

            HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");

    }

done:

    FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__compact_readvv() */

/*-------------------------------------------------------------------------

 * Function:    H5D__compact_writevv

 *

 * Purpose:     Writes some data vectors from a dataset into a buffer.

 *              The data is in compact dataset.  The address is relative

 *              to the beginning address for the file.  The offsets and

 *              sequence lengths are in bytes.  This function only copies

 *              data into the buffer in the LAYOUT struct and mark it

 *              as DIRTY.  Later in H5D_close, the data is copied into

 *              header message in memory.

 *

 * Return:      Non-negative on success/Negative on failure

 *

 * Notes:

 *              Offsets in the sequences must be monotonically increasing

 *

 *-------------------------------------------------------------------------

 */

static ssize_t

H5D__compact_writevv(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_info, size_t dset_max_nseq,

                     size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],

                     size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[],

                     hsize_t mem_offset_arr[])

{

    ssize_t ret_value = -1; /* Return value */

    FUNC_ENTER_PACKAGE

    assert(io_info);

    assert(dset_info);

    /* Check if file driver wishes to do its own memory management */

    if (H5F_SHARED_HAS_FEATURE(io_info->f_sh, H5FD_FEAT_MEMMANAGE)) {

        H5D_compact_iovv_memmanage_ud_t udata;

        /* Set up udata for memory copy operation */

        udata.f_sh   = io_info->f_sh;

        udata.dstbuf = dset_info->store->compact.buf;

        udata.srcbuf = dset_info->buf.cvp;

        /* Request that file driver does the memory copy */

        if ((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_size_arr, dset_offset_arr, mem_max_nseq,

                                   mem_curr_seq, mem_size_arr, mem_offset_arr, H5D__compact_iovv_memmanage_cb,

                                   &udata)) < 0)

            HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");

    }

    else {

        /* Use the vectorized memory copy routine to do actual work */

        if ((ret_value = H5VM_memcpyvv(dset_info->store->compact.buf, dset_max_nseq, dset_curr_seq,

                                       dset_size_arr, dset_offset_arr, dset_info->buf.cvp, mem_max_nseq,

                                       mem_curr_seq, mem_size_arr, mem_offset_arr)) < 0)

            HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");

    }

    /* Mark the compact dataset's buffer as dirty */

    *dset_info->store->compact.dirty = true;

done:

    FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__compact_writevv() */

/*-------------------------------------------------------------------------

 * Function:  H5D__compact_flush

 *

 * Purpose: Writes dirty compact data to object header

 *

 * Return:  Non-negative on success/Negative on failure

 *

 *-------------------------------------------------------------------------

 */

static herr_t

H5D__compact_flush(H5D_t *dset)

{

    herr_t ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE

    /* Sanity check */

    assert(dset);

    /* Check if the buffered compact information is dirty */

    if (dset->shared->layout.storage.u.compact.dirty) {

        dset->shared->layout.storage.u.compact.dirty = false;

        if (H5O_msg_write(&(dset->oloc), H5O_LAYOUT_ID, 0, H5O_UPDATE_TIME, &(dset->shared->layout)) < 0) {

            dset->shared->layout.storage.u.compact.dirty = true;

            HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "unable to update layout message");

        }

    } /* end if */

done:

    FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__compact_flush() */

/*-------------------------------------------------------------------------

 * Function:  H5D__compact_dest

 *

 * Purpose: Free the compact buffer

 *

 * Return:  Non-negative on success/Negative on failure

 *

 *-------------------------------------------------------------------------

 */

static herr_t

H5D__compact_dest(H5D_t *dset)

{

    FUNC_ENTER_PACKAGE_NOERR

    /* Sanity check */

    assert(dset);

    /* Free the buffer for the raw data for compact datasets */

    dset->shared->layout.storage.u.compact.buf = H5MM_xfree(dset->shared->layout.storage.u.compact.buf);

    FUNC_LEAVE_NOAPI(SUCCEED)

} /* end H5D__compact_dest() */

/*-------------------------------------------------------------------------

 * Function:    H5D__compact_copy

 *

 * Purpose:     Copy compact storage raw data from SRC file to DST file.

 *

 * Return:      Non-negative on success, negative on failure.

 *

 *-------------------------------------------------------------------------

 */

herr_t

H5D__compact_copy(H5F_t *f_src, H5O_storage_compact_t *_storage_src, H5F_t *f_dst,

                  H5O_storage_compact_t *storage_dst, H5T_t *dt_src, H5O_copy_t *cpy_info)

{

    H5T_t        *dt_mem      = NULL; /* Memory datatype */

    H5T_t        *dt_dst      = NULL; /* Destination datatype */

    H5S_t        *buf_space   = NULL; /* Dataspace describing buffer */

    void         *buf         = NULL; /* Buffer for copying data */

    void         *bkg         = NULL; /* Temporary buffer for copying data */

    void         *reclaim_buf = NULL; /* Buffer for reclaiming data */

    H5D_shared_t *shared_fo =

        (H5D_shared_t *)cpy_info->shared_fo;           /* Pointer to the shared struct for dataset object */

    H5O_storage_compact_t *storage_src = _storage_src; /* Pointer to storage_src */

    herr_t                 ret_value   = SUCCEED;      /* Return value */

    FUNC_ENTER_PACKAGE

    /* Check args */

    assert(f_src);

    assert(storage_src);

    assert(f_dst);

    assert(storage_dst);

    assert(storage_dst->buf);

    assert(dt_src);

    /* If the dataset is open in the file, point to "layout" in the shared struct */

    if (shared_fo != NULL)

        storage_src = &(shared_fo->layout.storage.u.compact);

    /* If there's a VLEN source datatype, do type conversion information */

    if (H5T_detect_class(dt_src, H5T_VLEN, false) > 0) {

        H5T_path_t *tpath_src_mem, *tpath_mem_dst; /* Datatype conversion paths */

        size_t      buf_size;                      /* Size of copy buffer */

        size_t      nelmts;                        /* Number of elements in buffer */

        size_t      src_dt_size;                   /* Source datatype size */

        size_t      tmp_dt_size;                   /* Temporary datatype size */

        size_t      max_dt_size;                   /* Max atatype size */

        hsize_t     buf_dim;                       /* Dimension for buffer */

        /* create a memory copy of the variable-length datatype */

        if (NULL == (dt_mem = H5T_copy(dt_src, H5T_COPY_TRANSIENT)))

            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to copy");

        /* create variable-length datatype at the destination file */

        if (NULL == (dt_dst = H5T_copy(dt_src, H5T_COPY_TRANSIENT)))

            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to copy");

        if (H5T_set_loc(dt_dst, H5F_VOL_OBJ(f_dst), H5T_LOC_DISK) < 0) {

            (void)H5T_close_real(dt_dst);

            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "cannot mark datatype on disk");

        } /* end if */

        /* Set up the conversion functions */

        if (NULL == (tpath_src_mem = H5T_path_find(dt_src, dt_mem)))

            HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to convert between src and mem datatypes");

        if (NULL == (tpath_mem_dst = H5T_path_find(dt_mem, dt_dst)))

            HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to convert between mem and dst datatypes");

        /* Determine largest datatype size */

        if (0 == (src_dt_size = H5T_get_size(dt_src)))

            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to determine datatype size");

        if (0 == (tmp_dt_size = H5T_get_size(dt_mem)))

            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to determine datatype size");

        max_dt_size = MAX(src_dt_size, tmp_dt_size);

        if (0 == (tmp_dt_size = H5T_get_size(dt_dst)))

            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to determine datatype size");

        max_dt_size = MAX(max_dt_size, tmp_dt_size);

        /* Set number of whole elements that fit in buffer */

        if (0 == (nelmts = storage_src->size / src_dt_size))

            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "element size too large");

        /* Set up number of bytes to copy, and initial buffer size */

        buf_size = nelmts * max_dt_size;

        /* Create dataspace for number of elements in buffer */

        buf_dim = nelmts;

        /* Create the space and set the initial extent */

        if (NULL == (buf_space = H5S_create_simple((unsigned)1, &buf_dim, NULL)))

            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCREATE, FAIL, "can't create simple dataspace");

        /* Allocate memory for recclaim buf */

        if (NULL == (reclaim_buf = H5FL_BLK_MALLOC(type_conv, buf_size)))

            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");

        /* Allocate memory for copying the chunk */

        if (NULL == (buf = H5FL_BLK_MALLOC(type_conv, buf_size)))

            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");

        H5MM_memcpy(buf, storage_src->buf, storage_src->size);

        /* allocate temporary bkg buff for data conversion */

        if (NULL == (bkg = H5FL_BLK_MALLOC(type_conv, buf_size)))

            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");

        /* Convert from source file to memory */

        if (H5T_convert(tpath_src_mem, dt_src, dt_mem, nelmts, (size_t)0, (size_t)0, buf, bkg) < 0)

            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTCONVERT, FAIL, "datatype conversion failed");

        /* Copy into another buffer, to reclaim memory later */

        H5MM_memcpy(reclaim_buf, buf, buf_size);

        /* Set background buffer to all zeros */

        memset(bkg, 0, buf_size);

        /* Convert from memory to destination file */

        if (H5T_convert(tpath_mem_dst, dt_mem, dt_dst, nelmts, (size_t)0, (size_t)0, buf, bkg) < 0)

            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTCONVERT, FAIL, "datatype conversion failed");

        H5MM_memcpy(storage_dst->buf, buf, storage_dst->size);

        if (H5T_reclaim(dt_mem, buf_space, reclaim_buf) < 0)

            HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to reclaim variable-length data");

    } /* end if */

    else if (H5T_get_class(dt_src, false) == H5T_REFERENCE) {

        if (f_src != f_dst) {

            /* Check for expanding references */

            if (cpy_info->expand_ref) {

                /* Copy objects referenced in source buffer to destination file and set destination elements

                 */

                if (H5O_copy_expand_ref(f_src, dt_src, storage_src->buf, storage_src->size, f_dst,

                                        storage_dst->buf, cpy_info) < 0)

                    HGOTO_ERROR(H5E_DATASET, H5E_CANTCOPY, FAIL, "unable to copy reference attribute");

            } /* end if */

            else

                /* Reset value to zero */

                memset(storage_dst->buf, 0, storage_src->size);

        } /* end if */

        else

            /* Type conversion not necessary */

            H5MM_memcpy(storage_dst->buf, storage_src->buf, storage_src->size);

    } /* end if */

    else

        /* Type conversion not necessary */

        H5MM_memcpy(storage_dst->buf, storage_src->buf, storage_src->size);

    /* Mark destination buffer as dirty */

    storage_dst->dirty = true;

done:

    if (dt_dst && (H5T_close(dt_dst) < 0))

        HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "can't close temporary datatype");

    if (dt_mem && (H5T_close(dt_mem) < 0))

        HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "can't close temporary datatype");

    if (buf_space && H5S_close(buf_space) < 0)

        HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "can't close temporary dataspace");

    if (buf)

        buf = H5FL_BLK_FREE(type_conv, buf);

    if (reclaim_buf)

        reclaim_buf = H5FL_BLK_FREE(type_conv, reclaim_buf);

    if (bkg)

        bkg = H5FL_BLK_FREE(type_conv, bkg);

    FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__compact_copy() */