/*-------------------------------------------------------------------------
* Function: H5O_sdsdpace_free
*
* Purpose: Free's the message
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Thursday, March 30, 2000
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_sdspace_free(void *mesg)
{
FUNC_ENTER_NOAPI_NOINIT_NOERR
HDassert(mesg);
mesg = H5FL_FREE(H5S_extent_t, mesg);
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5O_sdspace_free() */
/*-------------------------------------------------------------------------
* Function: H5O__ginfo_free
*
* Purpose: Frees the message
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Tuesday, August 30, 2005
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O__ginfo_free(void *mesg)
{
FUNC_ENTER_NOAPI_NOINIT_NOERR
HDassert(mesg);
mesg = H5FL_FREE(H5O_ginfo_t, mesg);
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5O__ginfo_free() */
/*-------------------------------------------------------------------------
* Function: H5D__single_idx_init
*
* Purpose: Initialize the indexing information for a dataset.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Vailin Choi
* July, 2011
*
*-------------------------------------------------------------------------
*/
static herr_t
H5D__single_idx_init(const H5D_chk_idx_info_t *idx_info,
const H5S_t H5_ATTR_UNUSED *space, haddr_t H5_ATTR_UNUSED dset_ohdr_addr)
{
FUNC_ENTER_STATIC_NOERR
/* Check args */
HDassert(idx_info);
HDassert(idx_info->f);
HDassert(idx_info->pline);
HDassert(idx_info->layout);
HDassert(idx_info->storage);
if(idx_info->pline->nused)
idx_info->layout->flags |= H5O_LAYOUT_CHUNK_SINGLE_INDEX_WITH_FILTER;
else
idx_info->layout->flags = 0;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5D__single_idx_init() */
/*-------------------------------------------------------------------------
* Function: H5G_traverse_link_ud
*
* Purpose: Callback for user-defined link traversal. Sets up a
* location ID and passes it to the user traversal callback.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Tuesday, September 13, 2005
*
*-------------------------------------------------------------------------
*/
static herr_t
H5G_traverse_ud(const H5G_loc_t *grp_loc/*in,out*/, const H5O_link_t *lnk,
H5G_loc_t *obj_loc/*in,out*/, size_t *nlinks/*in,out*/, hid_t _lapl_id,
hid_t dxpl_id)
{
const H5L_class_t *link_class; /* User-defined link class */
hid_t cb_return = -1; /* The ID the user-defined callback returned */
H5G_loc_t grp_loc_copy;
H5G_name_t grp_path_copy;
H5O_loc_t grp_oloc_copy;
H5O_loc_t *new_oloc = NULL;
H5F_t *temp_file = NULL;
H5G_t *grp;
hid_t lapl_id = (-1); /* LAPL local to this routine */
H5P_genplist_t *lapl; /* LAPL with nlinks set */
hid_t cur_grp = (-1);
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5G_traverse_ud)
/* Sanity check */
HDassert(grp_loc);
HDassert(lnk);
HDassert(lnk->type >= H5L_TYPE_UD_MIN);
HDassert(obj_loc);
HDassert(nlinks);
HDassert(_lapl_id >= 0);
/* Reset the object's path information, because we can't detect any changes
* in the "path" the user-defined callback takes */
H5G_name_free(obj_loc->path);
/* Get the link class for this type of link. */
if(NULL == (link_class = H5L_find_class(lnk->type)))
HGOTO_ERROR(H5E_LINK, H5E_NOTREGISTERED, FAIL, "unable to get UD link class")
/* Set up location for user-defined callback. Use a copy of our current
* grp_loc. */
grp_loc_copy.path = &grp_path_copy;
grp_loc_copy.oloc = &grp_oloc_copy;
H5G_loc_reset(&grp_loc_copy);
if(H5G_loc_copy(&grp_loc_copy, grp_loc, H5_COPY_DEEP) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTCOPY, FAIL, "unable to copy object location")
/* Create a group to pass to the user-defined callback */
if((grp = H5G_open(&grp_loc_copy, dxpl_id)) == NULL)
HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group")
if((cur_grp = H5I_register(H5I_GROUP, grp)) < 0)
HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register group")
/* Check for generic default property list and use link access default if so */
if(_lapl_id == H5P_DEFAULT) {
HDassert(H5P_LINK_ACCESS_DEFAULT != -1);
if(NULL == (lapl = H5I_object(H5P_LINK_ACCESS_DEFAULT)))
HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "unable to get default property list")
} /* end if */
/*------------------------------------------------------------------------- * Function: H5HF_man_iter_ready * * Purpose: Query if iterator is ready to use * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * [email protected] * Apr 25 2006 * *------------------------------------------------------------------------- */ hbool_t H5HF_man_iter_ready(H5HF_block_iter_t *biter) { FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_man_iter_ready) /* * Check arguments. */ HDassert(biter); FUNC_LEAVE_NOAPI(biter->ready) } /* end H5HF_man_iter_ready() */
/*------------------------------------------------------------------------- * Function: H5O_name_debug * * Purpose: Prints debugging info for the message. * * Return: Non-negative on success/Negative on failure * * Programmer: Robb Matzke * [email protected] * Aug 12 1997 * * Modifications: * *------------------------------------------------------------------------- */ static herr_t H5O_name_debug(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const void *_mesg, FILE *stream, int indent, int fwidth) { const H5O_name_t *mesg = (const H5O_name_t *)_mesg; FUNC_ENTER_NOAPI_NOINIT_NOERR /* check args */ HDassert(f); HDassert(mesg); HDassert(stream); HDassert(indent >= 0); HDassert(fwidth >= 0); fprintf(stream, "%*s%-*s `%s'\n", indent, "", fwidth, "Name:", mesg->s); FUNC_LEAVE_NOAPI(SUCCEED) }
/*------------------------------------------------------------------------- * Function: H5HF_man_iter_next * * Purpose: Advance to the next block within the current block of the heap * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * [email protected] * Apr 24 2006 * *------------------------------------------------------------------------- */ herr_t H5HF_man_iter_next(H5HF_hdr_t *hdr, H5HF_block_iter_t *biter, unsigned nentries) { FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_man_iter_next) /* * Check arguments. */ HDassert(biter); HDassert(biter->curr); HDassert(biter->curr->context); HDassert(biter->curr->row < biter->curr->context->nrows); /* Advance entry in current block */ biter->curr->entry += nentries; biter->curr->row = biter->curr->entry / hdr->man_dtable.cparam.width; biter->curr->col = biter->curr->entry % hdr->man_dtable.cparam.width; /* HDassert(biter->curr->row <= biter->curr->context->nrows); */ FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5HF_man_iter_next() */
/*-------------------------------------------------------------------------
* Function: H5D__single_idx_size
*
* Purpose: Retrieve the amount of index storage for the chunked dataset
*
* Return: Success: Non-negative
* Failure: negative
*
* Programmer: Vailin Choi; Sept 2011
*
*-------------------------------------------------------------------------
*/
static herr_t
H5D__single_idx_size(const H5D_chk_idx_info_t H5_ATTR_UNUSED *idx_info, hsize_t *index_size)
{
FUNC_ENTER_STATIC_NOERR
/* Check args */
HDassert(index_size);
*index_size = 0;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5D__single_idx_size() */
/*------------------------------------------------------------------------- * Function: H5O_mtime_encode * * Purpose: Encodes a modification time message. * * Return: Non-negative on success/Negative on failure * * Programmer: Robb Matzke * [email protected] * Jul 24 1998 * * Modifications: * *------------------------------------------------------------------------- */ static herr_t H5O_mtime_encode(H5F_t H5_ATTR_UNUSED *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, const void *_mesg) { const time_t *mesg = (const time_t *) _mesg; struct tm *tm; FUNC_ENTER_NOAPI_NOINIT_NOERR /* check args */ HDassert(f); HDassert(p); HDassert(mesg); /* encode */ tm = HDgmtime(mesg); sprintf((char*)p, "%04d%02d%02d%02d%02d%02d", 1900+tm->tm_year, 1+tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); FUNC_LEAVE_NOAPI(SUCCEED) }
/*-------------------------------------------------------------------------
* Function: h5_clean_files
*
* Purpose: Cleanup temporary test files (always).
* base_name contains the list of test file names.
*
* Return: void
*
* Programmer: Neil Fortner
* June 1, 2015
*
*-------------------------------------------------------------------------
*/
void
h5_clean_files(const char *base_name[], hid_t fapl)
{
int i;
for(i = 0; base_name[i]; i++) {
char filename[1024];
char temp[2048];
hid_t driver;
if(NULL == h5_fixname(base_name[i], fapl, filename, sizeof(filename)))
continue;
driver = H5Pget_driver(fapl);
if(driver == H5FD_FAMILY) {
int j;
for(j = 0; /*void*/; j++) {
HDsnprintf(temp, sizeof temp, filename, j);
if(HDaccess(temp, F_OK) < 0)
break;
HDremove(temp);
} /* end for */
} else if(driver == H5FD_CORE) {
hbool_t backing; /* Whether the core file has backing store */
H5Pget_fapl_core(fapl, NULL, &backing);
/* If the file was stored to disk with bacing store, remove it */
if(backing)
HDremove(filename);
} else if (driver == H5FD_MULTI) {
H5FD_mem_t mt;
HDassert(HDstrlen(multi_letters)==H5FD_MEM_NTYPES);
for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t,mt)) {
HDsnprintf(temp, sizeof temp, "%s-%c.h5", filename, multi_letters[mt]);
HDremove(temp); /*don't care if it fails*/
} /* end for */
} else {
HDremove(filename);
}
} /* end for */
/* Close the FAPL used to access the file */
H5Pclose(fapl);
return;
} /* end h5_clean_files() */
/*-------------------------------------------------------------------------
* Function: H5G_compact_build_table
*
* Purpose: Builds a table containing a sorted (alphabetically) list of
* links for a group
*
* Return: Success: Non-negative
* Failure: Negative
*
* Programmer: Quincey Koziol
* Sep 6, 2005
*
*-------------------------------------------------------------------------
*/
static herr_t
H5G_compact_build_table(const H5O_loc_t *oloc, hid_t dxpl_id, const H5O_linfo_t *linfo,
H5_index_t idx_type, H5_iter_order_t order, H5G_link_table_t *ltable)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5G_compact_build_table)
/* Sanity check */
HDassert(oloc);
HDassert(linfo);
HDassert(ltable);
/* Set size of table */
H5_CHECK_OVERFLOW(linfo->nlinks, hsize_t, size_t);
ltable->nlinks = (size_t)linfo->nlinks;
/* Allocate space for the table entries */
if(ltable->nlinks > 0) {
H5G_iter_bt_t udata; /* User data for iteration callback */
H5O_mesg_operator_t op; /* Message operator */
/* Allocate the link table */
if((ltable->lnks = (H5O_link_t *)H5MM_malloc(sizeof(H5O_link_t) * ltable->nlinks)) == NULL)
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
/* Set up user data for iteration */
udata.ltable = ltable;
udata.curr_lnk = 0;
/* Iterate through the link messages, adding them to the table */
op.op_type = H5O_MESG_OP_APP;
op.u.app_op = H5G_compact_build_table_cb;
if(H5O_msg_iterate(oloc, H5O_LINK_ID, &op, &udata, dxpl_id) < 0)
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "error iterating over link messages")
/* Sort link table in correct iteration order */
if(H5G_link_sort_table(ltable, idx_type, order) < 0)
HGOTO_ERROR(H5E_SYM, H5E_CANTSORT, FAIL, "error sorting link messages")
} /* end if */
/*-------------------------------------------------------------------------
* Function: H5F_cwfs_add
*
* Purpose: Add a global heap collection to the CWFS for a file.
*
* Return: Success: Non-negative
* Failure: Negative
*
* Programmer: Quincey Koziol
* Tuesday, July 19, 2011
*
*-------------------------------------------------------------------------
*/
herr_t
H5F_cwfs_add(H5F_t *f, H5HG_heap_t *heap)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Check args */
HDassert(f);
HDassert(f->shared);
HDassert(heap);
/*
* Add the new heap to the CWFS list, removing some other entry if
* necessary to make room. We remove the right-most entry that has less
* free space than this heap.
*/
if(NULL == f->shared->cwfs) {
if(NULL == (f->shared->cwfs = (H5HG_heap_t **)H5MM_malloc(H5F_NCWFS * sizeof(H5HG_heap_t *))))
HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, FAIL, "can't allocate CWFS for file")
f->shared->cwfs[0] = heap;
f->shared->ncwfs = 1;
} else if(H5F_NCWFS == f->shared->ncwfs) {
int i; /* Local index variable */
for(i = H5F_NCWFS - 1; i >= 0; --i)
if(H5HG_FREE_SIZE(f->shared->cwfs[i]) < H5HG_FREE_SIZE(heap)) {
HDmemmove(f->shared->cwfs + 1, f->shared->cwfs, (size_t)i * sizeof(H5HG_heap_t *));
f->shared->cwfs[0] = heap;
break;
} /* end if */
} else {
HDmemmove(f->shared->cwfs + 1, f->shared->cwfs, f->shared->ncwfs * sizeof(H5HG_heap_t *));
f->shared->cwfs[0] = heap;
f->shared->ncwfs += 1;
} /* end else */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5F_cwfs_add() */
/*-------------------------------------------------------------------------
* Function: H5O_layout_delete
*
* Purpose: Free file space referenced by message
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Wednesday, March 19, 2003
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_layout_delete(H5F_t *f, hid_t dxpl_id, H5O_t *open_oh, void *_mesg)
{
H5O_layout_t *mesg = (H5O_layout_t *) _mesg;
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/* check args */
HDassert(f);
HDassert(open_oh);
HDassert(mesg);
/* Perform different actions, depending on the type of storage */
switch(mesg->type) {
case H5D_COMPACT: /* Compact data storage */
/* Nothing required */
break;
case H5D_CONTIGUOUS: /* Contiguous block on disk */
/* Free the file space for the raw data */
if(H5D__contig_delete(f, dxpl_id, &mesg->storage) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to free raw data")
break;
case H5D_CHUNKED: /* Chunked blocks on disk */
/* Free the file space for the index & chunk raw data */
if(H5D__chunk_delete(f, dxpl_id, open_oh, &mesg->storage) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to free raw data")
break;
case H5D_LAYOUT_ERROR:
case H5D_NLAYOUTS:
default:
HGOTO_ERROR(H5E_OHDR, H5E_BADTYPE, FAIL, "not valid storage type")
} /* end switch */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_layout_delete() */
/*-------------------------------------------------------------------------
* Function: H5D__scatter_file
*
* Purpose: Scatters dataset elements from the type conversion buffer BUF
* to the file F where the data points are arranged according to
* the file dataspace FILE_SPACE and stored according to
* LAYOUT and EFL. Each element is ELMT_SIZE bytes.
* The caller is requesting that NELMTS elements are copied.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Thursday, June 20, 2002
*
*-------------------------------------------------------------------------
*/
static herr_t
H5D__scatter_file(const H5D_io_info_t *_io_info,
const H5S_t *space, H5S_sel_iter_t *iter, size_t nelmts,
const void *_buf)
{
H5D_io_info_t tmp_io_info; /* Temporary I/O info object */
hsize_t _off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets */
hsize_t *off = NULL; /* Pointer to sequence offsets */
hsize_t mem_off; /* Offset in memory */
size_t mem_curr_seq; /* "Current sequence" in memory */
size_t dset_curr_seq; /* "Current sequence" in dataset */
size_t _len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths */
size_t *len = NULL; /* Array to store sequence lengths */
size_t orig_mem_len, mem_len; /* Length of sequence in memory */
size_t nseq; /* Number of sequences generated */
size_t nelem; /* Number of elements used in sequences */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_STATIC
/* Check args */
HDassert(_io_info);
HDassert(space);
HDassert(iter);
HDassert(nelmts > 0);
HDassert(_buf);
/* Set up temporary I/O info object */
HDmemcpy(&tmp_io_info, _io_info, sizeof(*_io_info));
tmp_io_info.op_type = H5D_IO_OP_WRITE;
tmp_io_info.u.wbuf = _buf;
/* Allocate the vector I/O arrays */
if(tmp_io_info.dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE) {
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, tmp_io_info.dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, tmp_io_info.dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O offset vector array")
} /* end if */
else {
/*------------------------------------------------------------------------- * Function: H5HF_man_iter_down * * Purpose: Move iterator down one level * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * [email protected] * Apr 24 2006 * *------------------------------------------------------------------------- */ herr_t H5HF_man_iter_down(H5HF_block_iter_t *biter, H5HF_indirect_t *iblock) { H5HF_block_loc_t *down_loc = NULL; /* Pointer to new 'down' block location */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5HF_man_iter_down) /* * Check arguments. */ HDassert(biter); HDassert(biter->ready); HDassert(biter->curr); HDassert(biter->curr->context); /* Create new location to move down to */ if(NULL == (down_loc = H5FL_MALLOC(H5HF_block_loc_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for direct block free list section") /* Initialize down location */ down_loc->row = 0; down_loc->col = 0; down_loc->entry = 0; down_loc->context = iblock; down_loc->up = biter->curr; /* Increment reference count on indirect block */ if(H5HF_iblock_incr(down_loc->context) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared indirect block") /* Make down location the current location */ biter->curr = down_loc; done: if(ret_value < 0 && down_loc) down_loc = H5FL_FREE(H5HF_block_loc_t, down_loc); FUNC_LEAVE_NOAPI(ret_value) } /* end H5HF_man_iter_down() */
/*-------------------------------------------------------------------------
* Function: H5D__single_idx_remove
*
* Purpose: Remove the single chunk
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Vailin Choi; July 2011
*
*-------------------------------------------------------------------------
*/
static herr_t
H5D__single_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t H5_ATTR_UNUSED *udata)
{
hsize_t nbytes; /* Size of all chunks */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_STATIC
/* Sanity checks */
HDassert(idx_info);
HDassert(idx_info->f);
HDassert(idx_info->pline);
HDassert(idx_info->layout);
HDassert(idx_info->storage);
HDassert(H5F_addr_defined(idx_info->storage->idx_addr));
if(idx_info->layout->flags & H5O_LAYOUT_CHUNK_SINGLE_INDEX_WITH_FILTER)
nbytes = idx_info->storage->u.single.nbytes;
else
nbytes = idx_info->layout->size;
if(H5MF_xfree(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, idx_info->storage->idx_addr, nbytes) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, H5_ITER_ERROR, "unable to free dataset chunks")
idx_info->storage->idx_addr = HADDR_UNDEF;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5D__single_idx_remove() */
/*------------------------------------------------------------------------- * Function: H5G__ent_to_link * * Purpose: Convert a symbol table entry to a link * * Return: Non-negative on success/Negative on failure * * Programmer: Quincey Koziol * [email protected] * Sep 16 2006 * *------------------------------------------------------------------------- */ herr_t H5G__ent_to_link(H5O_link_t *lnk, const H5HL_t *heap, const H5G_entry_t *ent, const char *name) { hbool_t dup_soft = FALSE; /* xstrdup the symbolic link name or not */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_PACKAGE /* check arguments */ HDassert(lnk); HDassert(heap); HDassert(ent); HDassert(name); /* Set (default) common info for link */ lnk->cset = H5F_DEFAULT_CSET; lnk->corder = 0; lnk->corder_valid = FALSE; /* Creation order not valid for this link */ if((lnk->name = H5MM_xstrdup(name)) == NULL) HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "unable to duplicate link name") /* Object is a symbolic or hard link */ if(ent->type == H5G_CACHED_SLINK) { const char *s; /* Pointer to link value */ if((s = (const char *)H5HL_offset_into(heap, ent->cache.slink.lval_offset)) == NULL) HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "unable to get symbolic link name") /* Copy the link value */ if((lnk->u.soft.name = H5MM_xstrdup(s)) == NULL) HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "unable to duplicate symbolic link name") dup_soft = TRUE; /* Set link type */ lnk->type = H5L_TYPE_SOFT; } /* end if */ else {
/*-------------------------------------------------------------------------
* Function: H5O__drvinfo_debug
*
* Purpose: Prints debugging info for the message.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Mar 1, 2007
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O__drvinfo_debug(H5F_t H5_ATTR_UNUSED *f, const void *_mesg, FILE *stream,
int indent, int fwidth)
{
const H5O_drvinfo_t *mesg = (const H5O_drvinfo_t *)_mesg;
FUNC_ENTER_STATIC_NOERR
/* Sanity check */
HDassert(f);
HDassert(mesg);
HDassert(stream);
HDassert(indent >= 0);
HDassert(fwidth >= 0);
HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
"Driver name:", mesg->name);
HDfprintf(stream, "%*s%-*s %Zu\n", indent, "", fwidth,
"Buffer size:", mesg->len);
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5O__drvinfo_debug() */
/*-------------------------------------------------------------------------
* Function: H5O_drvinfo_encode
*
* Purpose: Encode a v1 B-tree 'K' value message.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Mar 1, 2007
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_drvinfo_encode(H5F_t H5_ATTR_UNUSED *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, const void *_mesg)
{
const H5O_drvinfo_t *mesg = (const H5O_drvinfo_t *)_mesg;
FUNC_ENTER_NOAPI_NOINIT_NOERR
/* Sanity check */
HDassert(f);
HDassert(p);
HDassert(mesg);
/* Store version, driver name, buffer length, & encoded buffer */
*p++ = H5O_DRVINFO_VERSION;
HDmemcpy(p, mesg->name, 8);
p += 8;
HDassert(mesg->len <= 65535);
UINT16ENCODE(p, mesg->len);
HDmemcpy(p, mesg->buf, mesg->len);
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5O_drvinfo_encode() */
/*-------------------------------------------------------------------------
* Function: H5D__single_idx_create
*
* Purpose: Set up Single Chunk Index: filtered or non-filtered
*
* Return: Non-negative on success
* Negative on failure.
*
* Programmer: Vailin Choi; July 2011
*
*-------------------------------------------------------------------------
*/
static herr_t
H5D__single_idx_create(const H5D_chk_idx_info_t *idx_info)
{
FUNC_ENTER_STATIC_NOERR
/* Check args */
HDassert(idx_info);
HDassert(idx_info->f);
HDassert(idx_info->pline);
HDassert(idx_info->layout);
HDassert(idx_info->storage);
HDassert(idx_info->layout->max_nchunks == idx_info->layout->nchunks);
HDassert(idx_info->layout->nchunks == 1);
HDassert(!H5F_addr_defined(idx_info->storage->idx_addr));
if(idx_info->pline->nused)
HDassert(idx_info->layout->flags & H5O_LAYOUT_CHUNK_SINGLE_INDEX_WITH_FILTER);
else
HDassert(!(idx_info->layout->flags & H5O_LAYOUT_CHUNK_SINGLE_INDEX_WITH_FILTER));
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5D__single_idx_create() */
/*--------------------------------------------------------------------------
NAME
H5R_term_package
PURPOSE
Terminate various H5R objects
USAGE
void H5R_term_package()
RETURNS
void
DESCRIPTION
Release the atom group and any other resources allocated.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
Can't report errors...
Finishes shutting down the interface, after H5R_top_term_package()
is called
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
int
H5R_term_package(void)
{
int n = 0;
FUNC_ENTER_NOAPI_NOINIT_NOERR
if (H5_PKG_INIT_VAR) {
/* Sanity checks */
HDassert(0 == H5I_nmembers(H5I_REFERENCE));
HDassert(FALSE == H5R_top_package_initialize_s);
/* Destroy the reference id group */
n += (H5I_dec_type_ref(H5I_REFERENCE) > 0);
/* Mark closed */
if (0 == n)
H5_PKG_INIT_VAR = FALSE;
}
FUNC_LEAVE_NOAPI(n)
} /* end H5R_term_package() */
/*------------------------------------------------------------------------- * Function: H5O_ainfo_encode * * Purpose: Encodes a message. * * Return: Non-negative on success/Negative on failure * * Programmer: Quincey Koziol * [email protected] * Mar 6 2007 * *------------------------------------------------------------------------- */ static herr_t H5O_ainfo_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, const void *_mesg) { const H5O_ainfo_t *ainfo = (const H5O_ainfo_t *)_mesg; unsigned char flags; /* Flags for encoding attribute info */ FUNC_ENTER_NOAPI_NOINIT_NOERR /* check args */ HDassert(f); HDassert(p); HDassert(ainfo); /* Message version */ *p++ = H5O_AINFO_VERSION; /* The flags for the attribute indices */ flags = ainfo->track_corder ? H5O_AINFO_TRACK_CORDER : 0; flags = (unsigned char)(flags | (ainfo->index_corder ? H5O_AINFO_INDEX_CORDER : 0)); *p++ = flags; /* Max. creation order value for the object */ if(ainfo->track_corder) UINT16ENCODE(p, ainfo->max_crt_idx); /* Address of fractal heap to store "dense" attributes */ H5F_addr_encode(f, &p, ainfo->fheap_addr); /* Address of v2 B-tree to index names of attributes */ H5F_addr_encode(f, &p, ainfo->name_bt2_addr); /* Address of v2 B-tree to index creation order of attributes, if they are indexed */ if(ainfo->index_corder) H5F_addr_encode(f, &p, ainfo->corder_bt2_addr); else HDassert(!H5F_addr_defined(ainfo->corder_bt2_addr)); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5O_ainfo_encode() */
/*-------------------------------------------------------------------------
* Function: H5O_efl_size
*
* Purpose: Returns the size of the raw message in bytes not counting the
* message type or size fields, but only the data fields. This
* function doesn't take into account message alignment. This
* function doesn't count unused slots.
*
* Return: Success: Message data size in bytes.
*
* Failure: 0
*
* Programmer: Robb Matzke
* Tuesday, November 25, 1997
*
*-------------------------------------------------------------------------
*/
static size_t
H5O_efl_size(const H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, const void *_mesg)
{
const H5O_efl_t *mesg = (const H5O_efl_t *) _mesg;
size_t ret_value = 0;
FUNC_ENTER_NOAPI_NOINIT_NOERR
/* check args */
HDassert(f);
HDassert(mesg);
ret_value = (size_t)H5F_SIZEOF_ADDR(f) + /*heap address */
2 + /*slots allocated*/
2 + /*num slots used*/
4 + /*reserved */
mesg->nused * ((size_t)H5F_SIZEOF_SIZE(f) + /*name offset */
(size_t)H5F_SIZEOF_SIZE(f) + /*file offset */
(size_t)H5F_SIZEOF_SIZE(f)); /*file size */
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_efl_size() */
/*------------------------------------------------------------------------- * Function: H5HL_inc_rc * * Purpose: Increment ref. count on heap * * Return: Success: Non-negative * Failure: Negative * * Programmer: Quincey Koziol * [email protected] * Oct 12 2008 * *------------------------------------------------------------------------- */ static herr_t H5HL_inc_rc(H5HL_t *heap) { FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HL_inc_rc) /* check arguments */ HDassert(heap); /* Increment heap's ref. count */ heap->rc++; FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5HL_inc_rc() */
/*-------------------------------------------------------------------------
* Function: H5FS_stat_info
*
* Purpose: Retrieve metadata statistics for the free-space manager
*
* Return: SUCCEED (Can't fail)
*
* Programmer: Vailin Choi
* August 25th, 2008
*
*-------------------------------------------------------------------------
*/
herr_t
H5FS_stat_info(const H5F_t *f, const H5FS_t *frsp, H5FS_stat_t *stats)
{
FUNC_ENTER_NOAPI_NOINIT_NOERR
/* Check arguments. */
HDassert(frsp);
HDassert(stats);
/* Report statistics for free space */
stats->tot_space = frsp->tot_space;
stats->tot_sect_count = frsp->tot_sect_count;
stats->serial_sect_count = frsp->serial_sect_count;
stats->ghost_sect_count = frsp->ghost_sect_count;
stats->addr = frsp->addr;
stats->hdr_size = (hsize_t)H5FS_HEADER_SIZE(f);
stats->sect_addr = frsp->sect_addr;
stats->alloc_sect_size = frsp->alloc_sect_size;
stats->sect_size = frsp->sect_size;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5FS_stat_info() */
/*------------------------------------------------------------------------- * Function: H5O_chunk_add * * Purpose: Add new chunk for object header to metadata cache * * Return: Success: Non-negative * Failure: Negative * * Programmer: Quincey Koziol * [email protected] * Jul 13 2008 * *------------------------------------------------------------------------- */ herr_t H5O_chunk_add(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned idx) { H5O_chunk_proxy_t *chk_proxy = NULL; /* Proxy for chunk, to mark it dirty in the cache */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_TAG(dxpl_id, oh->cache_info.addr, FAIL) /* check args */ HDassert(f); HDassert(oh); HDassert(idx < oh->nchunks); HDassert(idx > 0); /* Allocate space for the object header data structure */ if(NULL == (chk_proxy = H5FL_CALLOC(H5O_chunk_proxy_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") /* Set the values in the chunk proxy */ chk_proxy->oh = oh; chk_proxy->chunkno = idx; /* Increment reference count on object header */ if(H5O_inc_rc(oh) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTINC, FAIL, "can't increment reference count on object header") /* Insert the chunk proxy into the cache */ if(H5AC_insert_entry(f, dxpl_id, H5AC_OHDR_CHK, oh->chunk[idx].addr, chk_proxy, H5AC__NO_FLAGS_SET) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "unable to cache object header chunk") chk_proxy = NULL; done: if(ret_value < 0) if(chk_proxy) chk_proxy = H5FL_FREE(H5O_chunk_proxy_t, chk_proxy); FUNC_LEAVE_NOAPI_TAG(ret_value, FAIL) } /* end H5O_chunk_add() */
/*--------------------------------------------------------------------------
NAME
H5O_attr_decode
PURPOSE
Decode a attribute message and return a pointer to a memory struct
with the decoded information
USAGE
void *H5O_attr_decode(f, dxpl_id, mesg_flags, p)
H5F_t *f; IN: pointer to the HDF5 file struct
hid_t dxpl_id; IN: DXPL for any I/O
unsigned mesg_flags; IN: Message flags to influence decoding
const uint8_t *p; IN: the raw information buffer
RETURNS
Pointer to the new message in native order on success, NULL on failure
DESCRIPTION
This function decodes the "raw" disk form of a attribute message
into a struct in memory native format. The struct is allocated within this
function using malloc() and is returned to the caller.
--------------------------------------------------------------------------*/
static void *
H5O_attr_decode(H5F_t *f, hid_t dxpl_id, H5O_t *open_oh, unsigned H5_ATTR_UNUSED mesg_flags,
unsigned *ioflags, const uint8_t *p)
{
H5A_t *attr = NULL;
H5S_extent_t *extent; /*extent dimensionality information */
size_t name_len; /*attribute name length */
size_t dt_size; /* Datatype size */
hssize_t sds_size; /* Signed Dataspace size */
hsize_t ds_size; /* Dataspace size */
unsigned flags = 0; /* Attribute flags */
H5A_t *ret_value = NULL; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/* check args */
HDassert(f);
HDassert(p);
if(NULL == (attr = H5FL_CALLOC(H5A_t)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
if(NULL == (attr->shared = H5FL_CALLOC(H5A_shared_t)))
HGOTO_ERROR(H5E_FILE, H5E_NOSPACE, NULL, "can't allocate shared attr structure")
/* Version number */
attr->shared->version = *p++;
if(attr->shared->version < H5O_ATTR_VERSION_1 || attr->shared->version > H5O_ATTR_VERSION_LATEST)
HGOTO_ERROR(H5E_ATTR, H5E_CANTLOAD, NULL, "bad version number for attribute message")
/* Get the flags byte if we have a later version of the attribute */
if(attr->shared->version >= H5O_ATTR_VERSION_2) {
flags = *p++;
/* Check for unknown flag */
if(flags & (unsigned)~H5O_ATTR_FLAG_ALL)
HGOTO_ERROR(H5E_ATTR, H5E_CANTLOAD, NULL, "unknown flag for attribute message")
} /* end if */
/*------------------------------------------------------------------------- * Function: H5MF_alloc_create * * Purpose: Create free space manager of TYPE for the file by creating * a free-space structure * * Return: Success: non-negative * Failure: negative * * Programmer: Quincey Koziol * [email protected] * Jan 8 2008 * *------------------------------------------------------------------------- */ static herr_t H5MF_alloc_create(H5F_t *f, hid_t dxpl_id, H5FD_mem_t type) { const H5FS_section_class_t *classes[] = { /* Free space section classes implemented for file */ H5MF_FSPACE_SECT_CLS_SIMPLE}; herr_t ret_value = SUCCEED; /* Return value */ H5FS_create_t fs_create; /* Free space creation parameters */ FUNC_ENTER_NOAPI_NOINIT /* * Check arguments. */ HDassert(f); HDassert(f->shared); HDassert(type != H5FD_MEM_NOLIST); HDassert(!H5F_addr_defined(f->shared->fs_addr[type])); HDassert(f->shared->fs_state[type] == H5F_FS_STATE_CLOSED); /* Set the free space creation parameters */ fs_create.client = H5FS_CLIENT_FILE_ID; fs_create.shrink_percent = H5MF_FSPACE_SHRINK; fs_create.expand_percent = H5MF_FSPACE_EXPAND; fs_create.max_sect_addr = 1 + H5VM_log2_gen((uint64_t)f->shared->maxaddr); fs_create.max_sect_size = f->shared->maxaddr; if(NULL == (f->shared->fs_man[type] = H5FS_create(f, dxpl_id, NULL, &fs_create, NELMTS(classes), classes, f, f->shared->alignment, f->shared->threshold))) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't initialize free space info") /* Set the state for the free space manager to "open", if it is now */ if(f->shared->fs_man[type]) f->shared->fs_state[type] = H5F_FS_STATE_OPEN; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5MF_alloc_create() */
/*-------------------------------------------------------------------------
* Function: H5B2_stat_info
*
* Purpose: Retrieve metadata statistics for a v2 B-tree
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* Monday, March 6, 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5B2_stat_info(H5B2_t *bt2, H5B2_stat_t *info)
{
FUNC_ENTER_NOAPI_NOINIT
/* Check arguments. */
HDassert(info);
/* Get information about the B-tree */
info->depth = bt2->hdr->depth;
info->nrecords = bt2->hdr->root.all_nrec;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5B2_stat_info() */
/*-------------------------------------------------------------------------
* Function: H5O_ainfo_delete
*
* Purpose: Free file space referenced by message. Note that open_oh
* *must* be non-NULL - this means that calls to
* H5O_msg_delete must include an oh if the type is ainfo.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Tuesday, March 6, 2007
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_ainfo_delete(H5F_t *f, hid_t dxpl_id, H5O_t *open_oh, void *_mesg)
{
H5O_ainfo_t *ainfo = (H5O_ainfo_t *)_mesg;
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/* check args */
HDassert(f);
HDassert(ainfo);
HDassert(open_oh);
/* If the object is using "dense" attribute storage, delete it */
if(H5F_addr_defined(ainfo->fheap_addr)) {
/* Delete the attribute */
if(H5A_dense_delete(f, dxpl_id, ainfo) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to free dense attribute storage")
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_ainfo_delete() */