mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-03-31 17:10:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r27424] Implement support for h5debug for VDS.

Browse Source 
Implement support for H5Pencode/decode with VDS properties.
Testing for H5Pencode/decode with VDS.
Relax assertion check for number of elements written to buffer as we do not
check for overlaps in mappings.
Other minor fixes/cleanup.

Tested: ummon
This commit is contained in:
Neil Fortner 2015-07-22 13:36:30 -05:00
parent a8fc7eeaec
commit 6bb109bf6d
6 changed files with 250 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/H5Dvirtual.c
View File

@ -1099,8 +1099,8 @@ H5D__virtual_set_extent_unlim(const H5D_t *dset, hid_t dxpl_id)
/* Sanity check */
HDassert(dset);
storage = &dset->shared->layout.storage.u.virt;
HDassert(dset->shared->layout.storage.type == H5D_VIRTUAL);
storage = &dset->shared->layout.storage.u.virt;
HDassert((storage->view == H5D_VDS_FIRST_MISSING) || (storage->view == H5D_VDS_LAST_AVAILABLE));
/* Get rank of VDS */
@ -1956,11 +1956,9 @@ H5D__virtual_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
} /* end for */
/* Fill unmapped part of buffer with fill value */
if(tot_nelmts != nelmts) {
if(tot_nelmts < nelmts) {
H5D_fill_value_t fill_status; /* Fill value status */
HDassert(tot_nelmts < nelmts);
/* Check the fill value status */
if(H5P_is_fill_value_defined(&io_info->dset->shared->dcpl_cache.fill, &fill_status) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't tell if fill value defined")
@ -1994,7 +1992,7 @@ H5D__virtual_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
#ifndef NDEBUG
/* Make sure the total number of elements written (including fill
* values) == nelmts */
* values) >= nelmts */
{
hssize_t select_nelmts; /* Number of elements in selection */
@ -2002,8 +2000,10 @@ H5D__virtual_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
if((select_nelmts = (hssize_t)H5S_GET_SELECT_NPOINTS(fill_space)) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "unable to get number of elements in selection")
/* Verify number of elements is correct */
HDassert((tot_nelmts + (hsize_t)select_nelmts) == nelmts);
/* Verify number of elements is correct. Note that since we
* don't check for overlap we can't assert that these are equal
*/
HDassert((tot_nelmts + (hsize_t)select_nelmts) >= nelmts);
} /* end block */
#endif /* NDEBUG */
} /* end if */

27
src/H5Olayout.c
View File

@ -545,11 +545,11 @@ H5O_layout_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, c
/* Encode each entry */
for(i = 0; i < mesg->storage.u.virt.list_nused; i++) {
/* Source file name */
(void)HDstrcpy((char *)heap_block_p, mesg->storage.u.virt.list[i].source_file_name);
(void)HDmemcpy((char *)heap_block_p, mesg->storage.u.virt.list[i].source_file_name, str_size[2 * i]);
heap_block_p += str_size[2 * i];
/* Source dataset name */
(void)HDstrcpy((char *)heap_block_p, mesg->storage.u.virt.list[i].source_dset_name);
(void)HDmemcpy((char *)heap_block_p, mesg->storage.u.virt.list[i].source_dset_name, str_size[(2 * i) + 1]);
heap_block_p += str_size[(2 * i) + 1];
/* Source selection */
@ -948,7 +948,7 @@ H5O_layout_debug(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const vo
FILE * stream, int indent, int fwidth)
{
const H5O_layout_t *mesg = (const H5O_layout_t *) _mesg;
unsigned u;
size_t u;
FUNC_ENTER_NOAPI_NOINIT_NOERR
@ -971,7 +971,7 @@ H5O_layout_debug(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const vo
"Number of dimensions:",
(unsigned long)(mesg->u.chunk.ndims));
HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Size:");
for(u = 0; u < mesg->u.chunk.ndims; u++)
for(u = 0; u < (size_t)mesg->u.chunk.ndims; u++)
HDfprintf(stream, "%s%lu", u ? ", " : "", (unsigned long)(mesg->u.chunk.dim[u]));
HDfprintf(stream, "}\n");
@ -1009,8 +1009,23 @@ H5O_layout_debug(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const vo
break;
case H5D_VIRTUAL:
HDassert(0 && "Not yet implemented...");//VDSINC
HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
"Type:", "Virtual");
HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth,
"Global heap address:", mesg->storage.u.virt.serial_list_hobjid.addr);
HDfprintf(stream, "%*s%-*s %Zu\n", indent, "", fwidth,
"Global heap index:", mesg->storage.u.virt.serial_list_hobjid.idx);
for(u = 0; u < mesg->storage.u.virt.list_nused; u++) {
HDfprintf(stream, "%*sMapping %u:\n", indent, "", u);
HDfprintf(stream, "%*s%-*s %s\n", indent + 3, "", fwidth - 3,
"Virtual selection:", "<Not yet implemented>");
HDfprintf(stream, "%*s%-*s %s\n", indent + 3, "", fwidth - 3,
"Source file name:", mesg->storage.u.virt.list[u].source_file_name);
HDfprintf(stream, "%*s%-*s %s\n", indent + 3, "", fwidth - 3,
"Source dataset name:", mesg->storage.u.virt.list[u].source_dset_name);
HDfprintf(stream, "%*s%-*s %s\n", indent + 3, "", fwidth - 3,
"Source selection:", "<Not yet implemented>");
} /* end for */
break;
case H5D_LAYOUT_ERROR:

186
src/H5Pdcpl.c
View File

@ -438,8 +438,12 @@ H5P__dcrt_layout_enc(const void *value, void **_pp, size_t *size)
{
const H5O_layout_t *layout = (const H5O_layout_t *)value; /* Create local aliases for values */
uint8_t **pp = (uint8_t **)_pp;
uint8_t *tmp_p;
size_t tmp_size;
size_t u; /* Local index variable */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_STATIC_NOERR
FUNC_ENTER_STATIC
/* Sanity check */
HDassert(layout);
@ -451,19 +455,84 @@ H5P__dcrt_layout_enc(const void *value, void **_pp, size_t *size)
/* If layout is chunked, encode chunking structure */
if(H5D_CHUNKED == layout->type) {
unsigned u; /* Local index variable */
/* Encode rank */
*(*pp)++ = (uint8_t)layout->u.chunk.ndims;
/* Encode chunk dims */
HDcompile_assert(sizeof(uint32_t) == sizeof(layout->u.chunk.dim[0]));
for(u = 0; u < layout->u.chunk.ndims; u++)
for(u = 0; u < (size_t)layout->u.chunk.ndims; u++)
UINT32ENCODE(*pp, layout->u.chunk.dim[u])
} /* end if */
else if(H5D_VIRTUAL == layout->type) {
HDassert(0 && "Not yet implemented...");//VDSINC
} /* end else */
uint64_t nentries = (uint64_t)layout->storage.u.virt.list_nused;
/* Encode number of entries */
UINT64ENCODE(*pp, nentries)
*size += (size_t)8;
/* Iterate over entries */
for(u = 0; u < layout->storage.u.virt.list_nused; u++) {
/* Source file name */
tmp_size = HDstrlen(layout->storage.u.virt.list[u].source_file_name) + (size_t)1;
(void)HDmemcpy(*pp, layout->storage.u.virt.list[u].source_file_name, tmp_size);
*pp += tmp_size;
*size += tmp_size;
/* Source dataset name */
tmp_size = HDstrlen(layout->storage.u.virt.list[u].source_dset_name) + (size_t)1;
(void)HDmemcpy(*pp, layout->storage.u.virt.list[u].source_dset_name, tmp_size);
*pp += tmp_size;
*size += tmp_size;
/* Source selection. Note that we are not passing the real
* allocated size because we do no know it. H5P__encode should
* have verified that the buffer is large enough for the entire
* list before we get here. */
tmp_size = (size_t)-1;
tmp_p = *pp;
if(H5S_encode(layout->storage.u.virt.list[u].source_select, pp, &tmp_size) < 0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTENCODE, FAIL, "unable to serialize source selection")
*size += (size_t)(*pp - tmp_p);
/* Virtual dataset selection. Same notes as above apply. */
tmp_size = (size_t)-1;
tmp_p = *pp;
if(H5S_encode(layout->storage.u.virt.list[u].source_dset.virtual_select, pp, &tmp_size) < 0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTENCODE, FAIL, "unable to serialize virtual selection")
*size += (size_t)(*pp - tmp_p);
} /* end for */
} /* end if */
} /* end if */
else if(H5D_VIRTUAL == layout->type) {
/* Calculate size of virtual layout info */
/* number of entries */
*size += (size_t)8;
/* NULL pointer to pass to H5S_encode */
tmp_p = NULL;
/* Iterate over entries */
for(u = 0; u < layout->storage.u.virt.list_nused; u++) {
/* Source file name */
tmp_size = HDstrlen(layout->storage.u.virt.list[u].source_file_name) + (size_t)1;
*size += tmp_size;
/* Source dataset name */
tmp_size = HDstrlen(layout->storage.u.virt.list[u].source_dset_name) + (size_t)1;
*size += tmp_size;
/* Source selection */
tmp_size = (size_t)0;
if(H5S_encode(layout->storage.u.virt.list[u].source_select, &tmp_p, &tmp_size) < 0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTENCODE, FAIL, "unable to serialize source selection")
*size += tmp_size;
/* Virtual dataset selection */
tmp_size = (size_t)0;
if(H5S_encode(layout->storage.u.virt.list[u].source_dset.virtual_select, &tmp_p, &tmp_size) < 0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTENCODE, FAIL, "unable to serialize virtual selection")
*size += tmp_size;
} /* end for */
} /* end if */
/* Size of layout type */
@ -475,7 +544,8 @@ H5P__dcrt_layout_enc(const void *value, void **_pp, size_t *size)
*size += layout->u.chunk.ndims * sizeof(uint32_t);
} /* end if */
FUNC_LEAVE_NOAPI(SUCCEED)
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5P__dcrt_layout_enc() */
@ -498,7 +568,7 @@ static herr_t
H5P__dcrt_layout_dec(const void **_pp, void *value)
{
const H5O_layout_t *layout; /* Storage layout */
H5O_layout_t chunk_layout; /* Layout structure for chunk info */
H5O_layout_t tmp_layout; /* Temporary local layout structure */
H5D_layout_t type; /* Layout type */
const uint8_t **pp = (const uint8_t **)_pp;
herr_t ret_value = SUCCEED; /* Return value */
@ -538,21 +608,111 @@ H5P__dcrt_layout_dec(const void **_pp, void *value)
unsigned u; /* Local index variable */
/* Initialize to default values */
chunk_layout = H5D_def_layout_chunk_g;
tmp_layout = H5D_def_layout_chunk_g;
/* Set rank & dimensions */
chunk_layout.u.chunk.ndims = (unsigned)ndims;
tmp_layout.u.chunk.ndims = (unsigned)ndims;
for(u = 0; u < ndims; u++)
UINT32DECODE(*pp, chunk_layout.u.chunk.dim[u])
UINT32DECODE(*pp, tmp_layout.u.chunk.dim[u])
/* Point at the newly set up struct */
layout = &chunk_layout;
layout = &tmp_layout;
} /* end else */
}
break;
case H5D_VIRTUAL:
HDassert(0 && "Not yet implemented...");//VDSINC
{
uint64_t nentries; /* Number of VDS mappings */
/* Decode number of entries */
UINT64DECODE(*pp, nentries)
if(nentries == (uint64_t)0)
/* Just use the default struct */
layout = &H5D_def_layout_virtual_g;
else {
size_t tmp_size;
size_t u; /* Local index variable */
/* Initialize to default values */
tmp_layout = H5D_def_layout_virtual_g;
/* Allocate entry list */
if(NULL == (tmp_layout.storage.u.virt.list = (H5O_storage_virtual_ent_t *)H5MM_calloc((size_t)nentries * sizeof(H5O_storage_virtual_ent_t))))
HGOTO_ERROR(H5E_PLIST, H5E_CANTALLOC, FAIL, "unable to allocate heap block")
tmp_layout.storage.u.virt.list_nalloc = (size_t)nentries;
tmp_layout.storage.u.virt.list_nused = (size_t)nentries;
/* Decode each entry */
for(u = 0; u < (size_t)nentries; u++) {
/* Source file name */
tmp_size = HDstrlen((const char *)*pp) + 1;
if(NULL == (tmp_layout.storage.u.virt.list[u].source_file_name = (char *)H5MM_malloc(tmp_size)))
HGOTO_ERROR(H5E_PLIST, H5E_CANTALLOC, FAIL, "unable to allocate memory for source file name")
(void)HDmemcpy(tmp_layout.storage.u.virt.list[u].source_file_name, *pp, tmp_size);
*pp += tmp_size;
/* Source dataset name */
tmp_size = HDstrlen((const char *)*pp) + 1;
if(NULL == (tmp_layout.storage.u.virt.list[u].source_dset_name = (char *)H5MM_malloc(tmp_size)))
HGOTO_ERROR(H5E_PLIST, H5E_CANTALLOC, FAIL, "unable to allocate memory for source dataset name")
(void)HDmemcpy(tmp_layout.storage.u.virt.list[u].source_dset_name, *pp, tmp_size);
*pp += tmp_size;
/* Source selection */
if(NULL == (tmp_layout.storage.u.virt.list[u].source_select = H5S_decode(pp)))
HGOTO_ERROR(H5E_PLIST, H5E_CANTDECODE, FAIL, "can't decode source space selection")
tmp_layout.storage.u.virt.list[u].source_space_status = H5O_VIRTUAL_STATUS_USER;
/* Virtual selection */
if(NULL == (tmp_layout.storage.u.virt.list[u].source_dset.virtual_select = H5S_decode(pp)))
HGOTO_ERROR(H5E_PLIST, H5E_CANTDECODE, FAIL, "can't decode virtual space selection")
tmp_layout.storage.u.virt.list[u].virtual_space_status = H5O_VIRTUAL_STATUS_USER;
/* Parse source file and dataset names for "printf"
* style format specifiers */
if(H5D_virtual_parse_source_name(tmp_layout.storage.u.virt.list[u].source_file_name, &tmp_layout.storage.u.virt.list[u].parsed_source_file_name, &tmp_layout.storage.u.virt.list[u].psfn_static_strlen, &tmp_layout.storage.u.virt.list[u].psfn_nsubs) < 0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTINIT, FAIL, "can't parse source file name")
if(H5D_virtual_parse_source_name(tmp_layout.storage.u.virt.list[u].source_dset_name, &tmp_layout.storage.u.virt.list[u].parsed_source_dset_name, &tmp_layout.storage.u.virt.list[u].psdn_static_strlen, &tmp_layout.storage.u.virt.list[u].psdn_nsubs) < 0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTINIT, FAIL, "can't parse source dataset name")
/* Set source names in source_dset struct */
if((tmp_layout.storage.u.virt.list[u].psfn_nsubs == 0)
&& (tmp_layout.storage.u.virt.list[u].psdn_nsubs == 0)) {
if(tmp_layout.storage.u.virt.list[u].parsed_source_file_name)
tmp_layout.storage.u.virt.list[u].source_dset.file_name = tmp_layout.storage.u.virt.list[u].parsed_source_file_name->name_segment;
else
tmp_layout.storage.u.virt.list[u].source_dset.file_name = tmp_layout.storage.u.virt.list[u].source_file_name;
if(tmp_layout.storage.u.virt.list[u].parsed_source_dset_name)
tmp_layout.storage.u.virt.list[u].source_dset.dset_name = tmp_layout.storage.u.virt.list[u].parsed_source_dset_name->name_segment;
else
tmp_layout.storage.u.virt.list[u].source_dset.dset_name = tmp_layout.storage.u.virt.list[u].source_dset_name;
} /* end if */
/* unlim_dim fields */
tmp_layout.storage.u.virt.list[u].unlim_dim_source = H5S_get_select_unlim_dim(tmp_layout.storage.u.virt.list[u].source_select);
tmp_layout.storage.u.virt.list[u].unlim_dim_virtual = H5S_get_select_unlim_dim(tmp_layout.storage.u.virt.list[u].source_dset.virtual_select);
tmp_layout.storage.u.virt.list[u].unlim_extent_source = HSIZE_UNDEF;
tmp_layout.storage.u.virt.list[u].unlim_extent_virtual = HSIZE_UNDEF;
tmp_layout.storage.u.virt.list[u].clip_size_source = HSIZE_UNDEF;
tmp_layout.storage.u.virt.list[u].clip_size_virtual = HSIZE_UNDEF;
/* Clipped selections */
if(tmp_layout.storage.u.virt.list[u].unlim_dim_virtual < 0) {
tmp_layout.storage.u.virt.list[u].source_dset.clipped_source_select = tmp_layout.storage.u.virt.list[u].source_select;
tmp_layout.storage.u.virt.list[u].source_dset.clipped_virtual_select = tmp_layout.storage.u.virt.list[u].source_dset.virtual_select;
} /* end if */
/* Update min_dims */
if(H5D_virtual_update_min_dims(&tmp_layout, u) < 0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTINIT, FAIL, "unable to update virtual dataset minimum dimensions")
} /* end for */
/* Point at the newly set up struct */
layout = &tmp_layout;
} /* end else */
} /* end block */
break;
case H5D_LAYOUT_ERROR:

44
src/H5S.c
View File

@ -53,8 +53,6 @@
/* Local Prototypes */
/********************/
static htri_t H5S_is_simple(const H5S_t *sdim);
static herr_t H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc);
static H5S_t *H5S_decode(const unsigned char *buf);
/*********************/
@ -1506,7 +1504,7 @@ H5Sencode(hid_t obj_id, void *buf, size_t *nalloc)
if (NULL==(dspace=(H5S_t *)H5I_object_verify(obj_id, H5I_DATASPACE)))
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
if(H5S_encode(dspace, (unsigned char *)buf, nalloc)<0)
if(H5S_encode(dspace, (unsigned char **)&buf, nalloc)<0)
HGOTO_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "can't encode datatype")
done:
@ -1530,8 +1528,8 @@ done:
*
*-------------------------------------------------------------------------
*/
static herr_t
H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc)
herr_t
H5S_encode(H5S_t *obj, unsigned char **p, size_t *nalloc)
{
size_t extent_size; /* Size of serialized dataspace extent */
hssize_t sselect_size; /* Signed size of serialized dataspace selection */
@ -1556,28 +1554,28 @@ H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc)
/* Verify the size of buffer. If it's not big enough, simply return the
* right size without filling the buffer. */
if(!buf || *nalloc < (extent_size + select_size + 1 + 1 + 1 + 4))
if(!*p || *nalloc < (extent_size + select_size + 1 + 1 + 1 + 4))
*nalloc = extent_size + select_size + 1 + 1 + 1 + 4;
else {
/* Encode the type of the information */
*buf++ = H5O_SDSPACE_ID;
*(*p)++ = H5O_SDSPACE_ID;
/* Encode the version of the dataspace information */
*buf++ = H5S_ENCODE_VERSION;
*(*p)++ = H5S_ENCODE_VERSION;
/* Encode the "size of size" information */
*buf++ = (unsigned char)H5F_SIZEOF_SIZE(f);
*(*p)++ = (unsigned char)H5F_SIZEOF_SIZE(f);
/* Encode size of extent information. Pointer is actually moved in this macro. */
UINT32ENCODE(buf, extent_size);
UINT32ENCODE(*p, extent_size);
/* Encode the extent part of dataspace */
if(H5O_msg_encode(f, H5O_SDSPACE_ID, TRUE, buf, obj) < 0)
if(H5O_msg_encode(f, H5O_SDSPACE_ID, TRUE, *p, obj) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTENCODE, FAIL, "can't encode extent space")
buf += extent_size;
*p += extent_size;
/* Encode the selection part of dataspace. */
if(H5S_SELECT_SERIALIZE(f, obj, &buf) < 0)
if(H5S_SELECT_SERIALIZE(f, obj, p) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTENCODE, FAIL, "can't encode select space")
} /* end else */
@ -1618,7 +1616,7 @@ H5Sdecode(const void *buf)
if(buf == NULL)
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "empty buffer")
if((ds = H5S_decode((const unsigned char *)buf)) == NULL)
if((ds = H5S_decode((const unsigned char **)&buf)) == NULL)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, FAIL, "can't decode object")
/* Register the type and return the ID */
@ -1646,8 +1644,8 @@ done:
*
*-------------------------------------------------------------------------
*/
static H5S_t*
H5S_decode(const unsigned char *buf)
H5S_t*
H5S_decode(const unsigned char **p)
{
H5S_t *ds;
H5S_extent_t *extent;
@ -1659,28 +1657,28 @@ H5S_decode(const unsigned char *buf)
FUNC_ENTER_NOAPI_NOINIT
/* Decode the type of the information */
if(*buf++ != H5O_SDSPACE_ID)
if(*(*p)++ != H5O_SDSPACE_ID)
HGOTO_ERROR(H5E_DATASPACE, H5E_BADMESG, NULL, "not an encoded dataspace")
/* Decode the version of the dataspace information */
if(*buf++ != H5S_ENCODE_VERSION)
if(*(*p)++ != H5S_ENCODE_VERSION)
HGOTO_ERROR(H5E_DATASPACE, H5E_VERSION, NULL, "unknown version of encoded dataspace")
/* Decode the "size of size" information */
sizeof_size = *buf++;
sizeof_size = *(*p)++;
/* Allocate "fake" file structure */
if(NULL == (f = H5F_fake_alloc(sizeof_size)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate fake file struct")
/* Decode size of extent information */
UINT32DECODE(buf, extent_size);
UINT32DECODE(*p, extent_size);
/* Decode the extent part of dataspace */
/* (pass mostly bogus file pointer and bogus DXPL) */
if((extent = (H5S_extent_t *)H5O_msg_decode(f, H5P_DEFAULT, NULL, H5O_SDSPACE_ID, buf))==NULL)
if((extent = (H5S_extent_t *)H5O_msg_decode(f, H5P_DEFAULT, NULL, H5O_SDSPACE_ID, *p))==NULL)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, NULL, "can't decode object")
buf += extent_size;
*p += extent_size;
/* Copy the extent into dataspace structure */
if((ds = H5FL_CALLOC(H5S_t))==NULL)
@ -1696,7 +1694,7 @@ H5S_decode(const unsigned char *buf)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, NULL, "unable to set all selection")
/* Decode the select part of dataspace. I believe this part always exists. */
if(H5S_SELECT_DESERIALIZE(f, &ds, &buf) < 0)
if(H5S_SELECT_DESERIALIZE(f, &ds, p) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, NULL, "can't decode space selection")
/* Set return value */

2
src/H5Sprivate.h
View File

@ -194,6 +194,8 @@ H5_DLL H5S_t *H5S_create(H5S_class_t type);
H5_DLL H5S_t *H5S_create_simple(unsigned rank, const hsize_t dims[/*rank*/],
const hsize_t maxdims[/*rank*/]);
H5_DLL herr_t H5S_set_latest_version(H5S_t *ds);
H5_DLL herr_t H5S_encode(H5S_t *obj, unsigned char **p, size_t *nalloc);
H5_DLL H5S_t *H5S_decode(const unsigned char **p);
H5_DLL herr_t H5S_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg, FILE *stream,
int indent, int fwidth);
#ifndef H5_NO_DEPRECATED_SYMBOLS

27
test/vds.c
View File

@ -25,6 +25,7 @@
typedef enum {
TEST_API_BASIC,
TEST_API_COPY_PLIST,
TEST_API_ENCDEC_PLIST,
TEST_API_CREATE_DSET,
TEST_API_REOPEN_DSET,
TEST_API_REOPEN_FILE,
@ -45,7 +46,6 @@ const char *FILENAME[] = {
#define TEST_IO_DIFFERENT_FILE 0x02u
#define TEST_IO_REOPEN_VIRT 0x04u
#define TEST_IO_NTESTS 0x08u
//VDSINC add close source, virtual file
#define LIST_DOUBLE_SIZE (H5D_VIRTUAL_DEF_LIST_SIZE + 1)
@ -331,6 +331,7 @@ test_api_get_ex_dcpl(test_api_config_t config, hid_t fapl, hid_t dcpl,
{
hid_t file = -1; /* File */
hid_t dset = -1; /* Virtual dataset */
void *plist_buf = NULL; /* Serialized property list buffer */
HDassert((config >= TEST_API_BASIC) && (config < TEST_API_NTESTS));
HDassert(fapl >= 0);
@ -386,6 +387,25 @@ test_api_get_ex_dcpl(test_api_config_t config, hid_t fapl, hid_t dcpl,
if((*ex_dcpl = H5Pcopy(dcpl)) < 0)
TEST_ERROR
} /* end if */
else if(config == TEST_API_ENCDEC_PLIST) {
size_t plist_buf_size;
/* Encode property list to plist_buf */
if(H5Pencode(dcpl, NULL, &plist_buf_size) < 0)
TEST_ERROR
if(NULL == (plist_buf = HDmalloc(plist_buf_size)))
TEST_ERROR
if(H5Pencode(dcpl, plist_buf, &plist_buf_size) < 0)
TEST_ERROR
/* Decode serialized property list to *ex_dcpl */
if((*ex_dcpl = H5Pdecode(plist_buf)) < 0)
TEST_ERROR
/* Free plist_buf */
HDfree(plist_buf);
plist_buf = NULL;
} /* end if */
else {
/* Simply copy the id to ex_dcpl and increment the ref count so ex_dcpl
* can be closed */
@ -403,6 +423,8 @@ error:
if(dset >= 0)
(void)H5Dclose(dset);
} H5E_END_TRY;
if(plist_buf)
HDfree(plist_buf);
return -1;
} /* end test_api_get_ex_dcpl() */
@ -440,6 +462,9 @@ test_api(test_api_config_t config, hid_t fapl)
case TEST_API_COPY_PLIST:
TESTING("virtual dataset API functions with copied plists")
break;
case TEST_API_ENCDEC_PLIST:
TESTING("virtual dataset API functions with encoded and decoded plists")
break;
case TEST_API_CREATE_DSET:
TESTING("virtual dataset create")
break;