/*--------------------------------------------------------------------------
NAME
H5O_sdspace_copy
PURPOSE
Copies a message from MESG to DEST, allocating DEST if necessary.
USAGE
void *H5O_sdspace_copy(_mesg, _dest)
const void *_mesg; IN: Pointer to the source extent dimensionality struct
const void *_dest; IN: Pointer to the destination extent dimensionality struct
RETURNS
Pointer to DEST on success, NULL on failure
DESCRIPTION
This function copies a native (memory) simple dimensionality message,
allocating the destination structure if necessary.
--------------------------------------------------------------------------*/
static void *
H5O_sdspace_copy(const void *_mesg, void *_dest)
{
const H5S_extent_t *mesg = (const H5S_extent_t *)_mesg;
H5S_extent_t *dest = (H5S_extent_t *)_dest;
void *ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_sdspace_copy)
/* check args */
HDassert(mesg);
if(!dest && NULL == (dest = H5FL_MALLOC(H5S_extent_t)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
/* Copy extent information */
if(H5S_extent_copy(dest, mesg, TRUE) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "can't copy extent")
/* Set return value */
ret_value = dest;
done:
if(NULL == ret_value)
if(dest && NULL == _dest)
dest = H5FL_FREE(H5S_extent_t, dest);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_sdspace_copy() */
/*-------------------------------------------------------------------------
* Function: H5O_sdspace_pre_copy_file
*
* Purpose: Perform any necessary actions before copying message between
* files
*
* Return: Success: Non-negative
*
* Failure: Negative
*
* Programmer: Quincey Koziol
* November 30, 2006
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_sdspace_pre_copy_file(H5F_t UNUSED *file_src, const void *mesg_src,
hbool_t UNUSED *deleted, const H5O_copy_t UNUSED *cpy_info, void *_udata)
{
const H5S_extent_t *src_space_extent = (const H5S_extent_t *)mesg_src; /* Source dataspace extent */
H5D_copy_file_ud_t *udata = (H5D_copy_file_ud_t *)_udata; /* Dataset copying user data */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_sdspace_pre_copy_file)
/* check args */
HDassert(file_src);
HDassert(src_space_extent);
/* If the user data is non-NULL, assume we are copying a dataset
* and make a copy of the dataspace extent for later in the object copying
* process. (We currently only need to make a copy of the dataspace extent
* if the layout is an early version, but that information isn't
* available here, so we just make a copy of it in all cases)
*/
if(udata) {
/* Allocate copy of dataspace extent */
if(NULL == (udata->src_space_extent = H5FL_MALLOC(H5S_extent_t)))
HGOTO_ERROR(H5E_DATASPACE, H5E_NOSPACE, FAIL, "dataspace extent allocation failed")
/* Create a copy of the dataspace extent */
if(H5S_extent_copy(udata->src_space_extent, src_space_extent, TRUE) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy extent")
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_dspace_pre_copy_file() */
/*------------------------------------------------------------------------- * Function: H5MP_create * * Purpose: Create a new memory pool * * Return: Pointer to the memory pool "header" on success/NULL on failure * * Programmer: Quincey Koziol * [email protected] * May 2 2005 * *------------------------------------------------------------------------- */ H5MP_pool_t * H5MP_create (size_t page_size, unsigned flags) { H5MP_pool_t *mp; /* New memory pool header */ H5MP_pool_t *ret_value; /* Return value */ FUNC_ENTER_NOAPI(H5MP_create, NULL) /* Allocate space for the pool header */ if (NULL==(mp = H5FL_MALLOC(H5MP_pool_t))) HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for memory pool header") /* Assign information */ mp->page_size = H5MP_BLOCK_ALIGN(page_size); mp->flags = flags; /* Initialize information */ mp->free_size = 0; mp->first = NULL; mp->max_size = mp->page_size - H5MP_BLOCK_ALIGN(sizeof(H5MP_page_t)); /* Create factory for pool pages */ if((mp->page_fac=H5FL_fac_init(page_size))==NULL) HGOTO_ERROR (H5E_RESOURCE, H5E_CANTINIT, NULL, "can't create page factory") /* Set return value */ ret_value = mp; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5MP_create() */
/*-------------------------------------------------------------------------
* Function: H5SM__bt2_crt_context
*
* Purpose: Create client callback context
*
* Return: Success: non-NULL
* Failure: NULL
*
* Programmer: Quincey Koziol
* Thursday, November 26, 2009
*
*-------------------------------------------------------------------------
*/
static void *
H5SM__bt2_crt_context(void *_f)
{
H5F_t *f = (H5F_t *)_f; /* User data for building callback context */
H5SM_bt2_ctx_t *ctx; /* Callback context structure */
void *ret_value = NULL; /* Return value */
FUNC_ENTER_STATIC
/* Sanity check */
HDassert(f);
/* Allocate callback context */
if(NULL == (ctx = H5FL_MALLOC(H5SM_bt2_ctx_t)))
HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, NULL, "can't allocate callback context")
/* Determine the size of addresses & lengths in the file */
ctx->sizeof_addr = H5F_SIZEOF_ADDR(f);
/* Set return value */
ret_value = ctx;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5SM__bt2_crt_context() */
/*------------------------------------------------------------------------- * Function: H5O_refcount_decode * * Purpose: Decode a message and return a pointer to a newly allocated one. * * Return: Success: Ptr to new message in native form. * Failure: NULL * * Programmer: Quincey Koziol * [email protected] * Mar 10 2007 * *------------------------------------------------------------------------- */ static void * H5O_refcount_decode(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUSED mesg_flags, unsigned H5_ATTR_UNUSED *ioflags, const uint8_t *p) { H5O_refcount_t *refcount = NULL; /* Reference count */ void *ret_value = NULL; /* Return value */ FUNC_ENTER_NOAPI_NOINIT /* check args */ HDassert(f); HDassert(p); /* Version of message */ if(*p++ != H5O_REFCOUNT_VERSION) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad version number for message") /* Allocate space for message */ if(NULL == (refcount = H5FL_MALLOC(H5O_refcount_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Get ref. count for object */ UINT32DECODE(p, *refcount) /* Set return value */ ret_value = refcount; done: if(ret_value == NULL && refcount != NULL) refcount = H5FL_FREE(H5O_refcount_t, refcount); FUNC_LEAVE_NOAPI(ret_value) } /* end H5O_refcount_decode() */
/*------------------------------------------------------------------------- * Function: H5O_mtime_new_decode * * Purpose: Decode a new modification time message and return a pointer to a * new time_t value. * * Return: Success: Ptr to new message in native struct. * * Failure: NULL * * Programmer: Quincey Koziol * [email protected] * Jan 3 2002 * *------------------------------------------------------------------------- */ static void * H5O_mtime_new_decode(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, H5O_t UNUSED *open_oh, unsigned UNUSED mesg_flags, unsigned UNUSED *ioflags, const uint8_t *p) { time_t *mesg; uint32_t tmp_time; /* Temporary copy of the time */ void *ret_value; /* Return value */ FUNC_ENTER_NOAPI_NOINIT /* check args */ assert(f); assert(p); /* decode */ if(*p++ != H5O_MTIME_VERSION) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad version number for mtime message"); /* Skip reserved bytes */ p+=3; /* Get the time_t from the file */ UINT32DECODE(p, tmp_time); /* The return value */ if (NULL==(mesg = H5FL_MALLOC(time_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); *mesg = (time_t)tmp_time; /* Set return value */ ret_value=mesg; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5O_mtime_new_decode() */
/*------------------------------------------------------------------------- * Function: H5O_ainfo_decode * * Purpose: Decode a message and return a pointer to a newly allocated one. * * Return: Success: Ptr to new message in native form. * Failure: NULL * * Programmer: Quincey Koziol * [email protected] * Mar 6 2007 * *------------------------------------------------------------------------- */ static void * H5O_ainfo_decode(H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUSED mesg_flags, unsigned H5_ATTR_UNUSED *ioflags, const uint8_t *p) { H5O_ainfo_t *ainfo = NULL; /* Attribute info */ unsigned char flags; /* Flags for encoding attribute info */ void *ret_value = NULL; /* Return value */ FUNC_ENTER_NOAPI_NOINIT /* check args */ HDassert(f); HDassert(p); /* Version of message */ if(*p++ != H5O_AINFO_VERSION) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad version number for message") /* Allocate space for message */ if(NULL == (ainfo = H5FL_MALLOC(H5O_ainfo_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Get the flags for the message */ flags = *p++; if(flags & ~H5O_AINFO_ALL_FLAGS) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad flag value for message") ainfo->track_corder = (flags & H5O_AINFO_TRACK_CORDER) ? TRUE : FALSE; ainfo->index_corder = (flags & H5O_AINFO_INDEX_CORDER) ? TRUE : FALSE; /* Set the number of attributes on the object to an invalid value, so we query it later */ ainfo->nattrs = HSIZET_MAX; /* Max. creation order value for the object */ if(ainfo->track_corder) UINT16DECODE(p, ainfo->max_crt_idx) else ainfo->max_crt_idx = H5O_MAX_CRT_ORDER_IDX; /* Address of fractal heap to store "dense" attributes */ H5F_addr_decode(f, &p, &(ainfo->fheap_addr)); /* Address of v2 B-tree to index names of attributes (names are always indexed) */ H5F_addr_decode(f, &p, &(ainfo->name_bt2_addr)); /* Address of v2 B-tree to index creation order of links, if there is one */ if(ainfo->index_corder) H5F_addr_decode(f, &p, &(ainfo->corder_bt2_addr)); else ainfo->corder_bt2_addr = HADDR_UNDEF; /* Set return value */ ret_value = ainfo; done: if(ret_value == NULL && ainfo != NULL) ainfo = H5FL_FREE(H5O_ainfo_t, ainfo); FUNC_LEAVE_NOAPI(ret_value) } /* end H5O_ainfo_decode() */
/*--------------------------------------------------------------------------
NAME
H5HP_create
PURPOSE
Create a heap
USAGE
H5HP_t *H5HP_create(heap_type)
H5HP_type_t heap_type; IN: Type of heap to create
RETURNS
Returns a pointer to a heap on success, NULL on failure.
DESCRIPTION
Create a priority queue. The SIZE is used to set the initial number of
entries allocated.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
H5HP_t *
H5HP_create(H5HP_type_t heap_type)
{
H5HP_t *new_heap=NULL; /* Pointer to new heap object created */
H5HP_t *ret_value; /* Return value */
FUNC_ENTER_NOAPI(NULL)
/* Check args */
HDassert(heap_type==H5HP_MIN_HEAP || heap_type==H5HP_MAX_HEAP);
/* Allocate ref-counted string structure */
if((new_heap=H5FL_MALLOC(H5HP_t))==NULL)
HGOTO_ERROR(H5E_HEAP,H5E_NOSPACE,NULL,"memory allocation failed");
/* Allocate the array to store the heap entries */
if((new_heap->heap = H5FL_SEQ_MALLOC(H5HP_ent_t, (size_t)(H5HP_START_SIZE + 1)))==NULL)
HGOTO_ERROR(H5E_HEAP,H5E_NOSPACE,NULL,"memory allocation failed");
/* Set the internal fields */
new_heap->type=heap_type;
new_heap->nobjs=0;
new_heap->nalloc=H5HP_START_SIZE+1;
/* Set the information in the 0'th location based on the type of heap */
if(heap_type==H5HP_MIN_HEAP) {
/* Set the value in the '0' location to be the minimum value, to
* simplify the algorithms
*/
new_heap->heap[0].val=INT_MIN;
new_heap->heap[0].obj=NULL;
} /* end if */
else {
/* Set the value in the '0' location to be the maximum value, to
* simplify the algorithms
*/
new_heap->heap[0].val=INT_MAX;
new_heap->heap[0].obj=NULL;
} /* end else */
/* Set the return value */
ret_value=new_heap;
done:
/* Error cleanup */
if(NULL ==ret_value) {
if(NULL != new_heap) {
if(NULL != new_heap->heap)
new_heap->heap = H5FL_SEQ_FREE(H5HP_ent_t, new_heap->heap);
new_heap = H5FL_FREE(H5HP_t, new_heap);
} /* end if */
} /* end if */
FUNC_LEAVE_NOAPI(ret_value);
} /* end H5HP_create() */
/*-------------------------------------------------------------------------
* Function: H5O_ainfo_copy_file
*
* Purpose: Copies a message from _MESG to _DEST in file
*
* Return: Success: Ptr to _DEST
* Failure: NULL
*
* Programmer: Peter Cao
* July 18, 2007
*
*-------------------------------------------------------------------------
*/
static void *
H5O_ainfo_copy_file(H5F_t *file_src, void *mesg_src, H5F_t *file_dst,
hbool_t H5_ATTR_UNUSED *recompute_size, unsigned H5_ATTR_UNUSED *mesg_flags,
H5O_copy_t *cpy_info, void H5_ATTR_UNUSED *udata, hid_t dxpl_id)
{
H5O_ainfo_t *ainfo_src = (H5O_ainfo_t *)mesg_src;
H5O_ainfo_t *ainfo_dst = NULL;
void *ret_value = NULL; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/* check args */
HDassert(file_src);
HDassert(ainfo_src);
HDassert(file_dst);
HDassert(cpy_info);
HDassert(!cpy_info->copy_without_attr);
/* Allocate space for the destination message */
if(NULL == (ainfo_dst = H5FL_MALLOC(H5O_ainfo_t)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
/* Copy the top level of the information */
*ainfo_dst = *ainfo_src;
if(H5F_addr_defined(ainfo_src->fheap_addr)) {
/* Prepare to copy dense attributes - actual copy in post_copy */
/* Set copied metadata tag */
H5_BEGIN_TAG(dxpl_id, H5AC__COPIED_TAG, NULL);
if(H5A_dense_create(file_dst, dxpl_id, ainfo_dst) < 0)
HGOTO_ERROR_TAG(H5E_OHDR, H5E_CANTINIT, NULL, "unable to create dense storage for attributes")
/* Reset metadata tag */
H5_END_TAG(NULL);
} /* end if */
/* Set return value */
ret_value = ainfo_dst;
done:
/* Release destination attribute information on failure */
if(!ret_value && ainfo_dst)
ainfo_dst = H5FL_FREE(H5O_ainfo_t, ainfo_dst);
FUNC_LEAVE_NOAPI(ret_value)
} /* H5O_ainfo_copy_file() */
/*------------------------------------------------------------------------- * Function: H5HF_man_iter_start_entry * * Purpose: Initialize a block iterator to a particular location within * an indirect block * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * [email protected] * Apr 24 2006 * *------------------------------------------------------------------------- */ herr_t H5HF_man_iter_start_entry(H5HF_hdr_t *hdr, H5HF_block_iter_t *biter, H5HF_indirect_t *iblock, unsigned start_entry) { H5HF_block_loc_t *new_loc = NULL; /* Pointer to new block location */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5HF_man_iter_start_entry) /* * Check arguments. */ HDassert(hdr); HDassert(biter); HDassert(!biter->ready); HDassert(iblock); /* Create new location for iterator */ if(NULL == (new_loc = H5FL_MALLOC(H5HF_block_loc_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for direct block free list section") /* Set up location context */ new_loc->entry = start_entry; new_loc->row = start_entry / hdr->man_dtable.cparam.width; new_loc->col = start_entry % hdr->man_dtable.cparam.width; new_loc->context = iblock; new_loc->up = NULL; /* Increment reference count on indirect block */ if(H5HF_iblock_incr(new_loc->context) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared indirect block") /* Make new location the current location */ biter->curr = new_loc; /* Set flag to indicate block iterator finished initializing */ biter->ready = TRUE; done: if(ret_value < 0 && new_loc) new_loc = H5FL_FREE(H5HF_block_loc_t, new_loc); FUNC_LEAVE_NOAPI(ret_value) } /* end H5HF_man_iter_start_entry() */
/*------------------------------------------------------------------------- * Function: H5O_mtime_decode * * Purpose: Decode a modification time message and return a pointer to a * new time_t value. * * The new modification time message format was added due to the * performance overhead of the old format. * * Return: Success: Ptr to new message in native struct. * * Failure: NULL * * Programmer: Robb Matzke * [email protected] * Jul 24 1998 * *------------------------------------------------------------------------- */ static void * H5O_mtime_decode(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUSED mesg_flags, unsigned H5_ATTR_UNUSED *ioflags, const uint8_t *p) { time_t *mesg, the_time; struct tm tm; int i; /* Local index variable */ void *ret_value = NULL; /* Return value */ FUNC_ENTER_NOAPI_NOINIT /* check args */ HDassert(f); HDassert(p); /* decode */ for(i = 0; i < 14; i++) if(!HDisdigit(p[i])) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "badly formatted modification time message") /* Convert YYYYMMDDhhmmss UTC to a time_t. */ HDmemset(&tm, 0, sizeof tm); tm.tm_year = (p[0]-'0')*1000 + (p[1]-'0')*100 + (p[2]-'0')*10 + (p[3]-'0') - 1900; tm.tm_mon = (p[4]-'0')*10 + (p[5]-'0') - 1; tm.tm_mday = (p[6]-'0')*10 + (p[7]-'0'); tm.tm_hour = (p[8]-'0')*10 + (p[9]-'0'); tm.tm_min = (p[10]-'0')*10 + (p[11]-'0'); tm.tm_sec = (p[12]-'0')*10 + (p[13]-'0'); tm.tm_isdst = -1; /* (figure it out) */ if((time_t)-1 == (the_time = H5_make_time(&tm))) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "can't construct time info") /* The return value */ if(NULL == (mesg = H5FL_MALLOC(time_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") *mesg = the_time; /* Set return value */ ret_value = mesg; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5O_mtime_decode() */
/*-------------------------------------------------------------------------
* Function: H5O_layout_copy
*
* Purpose: Copies a message from _MESG to _DEST, allocating _DEST if
* necessary.
*
* Return: Success: Ptr to _DEST
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Wednesday, October 8, 1997
*
*-------------------------------------------------------------------------
*/
static void *
H5O_layout_copy(const void *_mesg, void *_dest)
{
const H5O_layout_t *mesg = (const H5O_layout_t *) _mesg;
H5O_layout_t *dest = (H5O_layout_t *) _dest;
void *ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_layout_copy)
/* check args */
HDassert(mesg);
/* Allocate destination message, if necessary */
if(!dest && NULL == (dest = H5FL_MALLOC(H5O_layout_t)))
HGOTO_ERROR(H5E_OHDR, H5E_CANTALLOC, NULL, "layout message allocation failed")
/* copy */
*dest = *mesg;
/* Deep copy the buffer for compact datasets also */
if(mesg->type == H5D_COMPACT && mesg->storage.u.compact.size > 0) {
/* Allocate memory for the raw data */
if(NULL == (dest->storage.u.compact.buf = H5MM_malloc(dest->storage.u.compact.size)))
HGOTO_ERROR(H5E_OHDR, H5E_NOSPACE, NULL, "unable to allocate memory for compact dataset")
/* Copy over the raw data */
HDmemcpy(dest->storage.u.compact.buf, mesg->storage.u.compact.buf, dest->storage.u.compact.size);
} /* end if */
/* Reset the pointer of the chunked storage index but not the address */
if(dest->type == H5D_CHUNKED && dest->storage.u.chunk.ops)
H5D_chunk_idx_reset(&dest->storage.u.chunk, FALSE);
/* Set return value */
ret_value = dest;
done:
if(ret_value == NULL)
if(NULL == _dest)
dest = H5FL_FREE(H5O_layout_t, dest);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_layout_copy() */
/*------------------------------------------------------------------------- * 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() */
/*--------------------------------------------------------------------------
NAME
H5RC_create
PURPOSE
Create a reference counted object
USAGE
H5RC_t *H5RC_create(o,free)
const void *o; IN: Object to initialize ref-counted object with
H5RC_free_func_t free; IN: Function to call when ref-count drop to zero
RETURNS
Returns a pointer to a new ref-counted object on success, NULL on failure.
DESCRIPTION
Create a reference counted object. The object is not duplicated, it is
assumed to be owned by the reference counted object now and will be freed
with the 'free' function when the reference count drops to zero.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
H5RC_t *
H5RC_create(void *o, H5RC_free_func_t free_func)
{
H5RC_t *ret_value; /* Return value */
FUNC_ENTER_NOAPI(H5RC_create, NULL)
/* Sanity check */
HDassert(o);
HDassert(free_func);
/* Allocate ref-counted string structure */
if(NULL == (ret_value = H5FL_MALLOC(H5RC_t)))
HGOTO_ERROR(H5E_RS,H5E_NOSPACE,NULL,"memory allocation failed")
/* Set the internal fields */
ret_value->o = o;
ret_value->n = 1;
ret_value->free_func = free_func;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5RC_create() */
/*------------------------------------------------------------------------- * Function: H5O_ainfo_copy * * Purpose: Copies a message from _MESG to _DEST, allocating _DEST if * necessary. * * Return: Success: Ptr to _DEST * Failure: NULL * * Programmer: Quincey Koziol * [email protected] * Mar 6 2007 * *------------------------------------------------------------------------- */ static void * H5O_ainfo_copy(const void *_mesg, void *_dest) { const H5O_ainfo_t *ainfo = (const H5O_ainfo_t *)_mesg; H5O_ainfo_t *dest = (H5O_ainfo_t *) _dest; void *ret_value = NULL; /* Return value */ FUNC_ENTER_NOAPI_NOINIT /* check args */ HDassert(ainfo); if(!dest && NULL == (dest = H5FL_MALLOC(H5O_ainfo_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* copy */ *dest = *ainfo; /* Set return value */ ret_value = dest; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5O_ainfo_copy() */
/*------------------------------------------------------------------------- * Function: H5O_mtime_copy * * Purpose: Copies a message from _MESG to _DEST, allocating _DEST if * necessary. * * Return: Success: Ptr to _DEST * * Failure: NULL * * Programmer: Robb Matzke * [email protected] * Jul 24 1998 * * Modifications: * *------------------------------------------------------------------------- */ static void * H5O_mtime_copy(const void *_mesg, void *_dest) { const time_t *mesg = (const time_t *) _mesg; time_t *dest = (time_t *) _dest; void *ret_value; /* Return value */ FUNC_ENTER_NOAPI_NOINIT /* check args */ assert(mesg); if (!dest && NULL==(dest = H5FL_MALLOC(time_t))) HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); /* copy */ *dest = *mesg; /* Set return value */ ret_value=dest; done: FUNC_LEAVE_NOAPI(ret_value) }
/*-------------------------------------------------------------------------
* Function: H5SM_bt2_crt_dbg_context
*
* Purpose: Create context for debugging callback
*
* Return: Success: non-NULL
* Failure: NULL
*
* Programmer: Quincey Koziol
* Tuesday, December 1, 2009
*
*-------------------------------------------------------------------------
*/
static void *
H5SM_bt2_crt_dbg_context(H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t H5_ATTR_UNUSED addr)
{
H5SM_bt2_ctx_t *ctx; /* Callback context structure */
void *ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/* Sanity check */
HDassert(f);
/* Allocate callback context */
if(NULL == (ctx = H5FL_MALLOC(H5SM_bt2_ctx_t)))
HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, NULL, "can't allocate callback context")
/* Determine the size of addresses & lengths in the file */
ctx->sizeof_addr = H5F_SIZEOF_ADDR(f);
/* Set return value */
ret_value = ctx;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5SM_bt2_crt_dbg_context() */
/*------------------------------------------------------------------------- * Function: H5HF_man_iter_start_offset * * Purpose: Initialize a block iterator to a particular location, given * an offset in the heap * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * [email protected] * Apr 24 2006 * *------------------------------------------------------------------------- */ herr_t H5HF_man_iter_start_offset(H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_block_iter_t *biter, hsize_t offset) { H5HF_indirect_t *iblock; /* Indirect block for location context */ haddr_t iblock_addr; /* Address of indirect block */ unsigned iblock_nrows; /* # of rows in indirect block */ H5HF_indirect_t *iblock_parent; /* Parent indirect block of location context */ unsigned iblock_par_entry; /* Entry within parent indirect block */ hsize_t curr_offset; /* Current offset, as adjusted */ unsigned row; /* Current row we are on */ unsigned col; /* Column in row */ hbool_t root_block = TRUE; /* Flag to indicate the current block is the root indirect block */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5HF_man_iter_start_offset) /* * Check arguments. */ HDassert(biter); HDassert(!biter->ready); /* Check for empty heap */ HDassert(offset >= hdr->man_dtable.cparam.start_block_size); /* Allocate level structure */ if(NULL == (biter->curr = H5FL_MALLOC(H5HF_block_loc_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for direct block free list section") /* 1: <Scan down block offsets for dtable rows until find a row >= offset> <Set current location's row, col, entry & size> <If row < max_direct_rows> <Done> <Else - row > max_direct_rows> <Create new block level> <Link new block level into iterator> <Adjust offset for block offset for row> <Make new block level the current context> <Goto 1> */ do { hbool_t did_protect; /* Whether we protected the indirect block or not */ /* Walk down the rows in the doubling table until we've found the correct row for the next block */ for(row = 0; row < hdr->man_dtable.max_root_rows; row++) if((offset >= hdr->man_dtable.row_block_off[row]) && (offset < hdr->man_dtable.row_block_off[row] + (hdr->man_dtable.cparam.width * hdr->man_dtable.row_block_size[row]))) break; /* Adjust offset by row offset */ curr_offset = offset - hdr->man_dtable.row_block_off[row]; /* Compute column */ H5_CHECK_OVERFLOW((curr_offset / hdr->man_dtable.row_block_size[row]), hsize_t, unsigned); col = (unsigned)(curr_offset / hdr->man_dtable.row_block_size[row]); /* Set the current level's context */ biter->curr->row = row; biter->curr->col = col; biter->curr->entry = (row * hdr->man_dtable.cparam.width) + col; /* Get the context indirect block's information */ if(root_block) { iblock_addr = hdr->man_dtable.table_addr; iblock_nrows = hdr->man_dtable.curr_root_rows; iblock_parent = NULL; iblock_par_entry = 0; /* The root block can't go up further... */ biter->curr->up = NULL; /* Next time through the loop will not be with the root indirect block */ root_block = FALSE; } /* end if */ else { hsize_t child_size; /* Size of new indirect block to create */ /* Retrieve the parent information from the previous context location */ iblock_parent = biter->curr->up->context; iblock_par_entry = biter->curr->up->entry; /* Look up the address of context indirect block */ iblock_addr = iblock_parent->ents[iblock_par_entry].addr; /* Compute # of rows in context indirect block */ child_size = hdr->man_dtable.row_block_size[biter->curr->up->row]; iblock_nrows = (H5V_log2_gen(child_size) - hdr->man_dtable.first_row_bits) + 1; } /* end else */ /* Load indirect block for this context location */ if(NULL == (iblock = H5HF_man_iblock_protect(hdr, dxpl_id, iblock_addr, iblock_nrows, iblock_parent, iblock_par_entry, FALSE, H5AC_WRITE, &did_protect))) HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to protect fractal heap indirect block") /* Make indirect block the context for the current location */ biter->curr->context = iblock; /* Hold the indirect block with the location */ if(H5HF_iblock_incr(biter->curr->context) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared indirect block") /* Release the current indirect block */ if(H5HF_man_iblock_unprotect(iblock, dxpl_id, H5AC__NO_FLAGS_SET, did_protect) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap indirect block") iblock = NULL; /* See if the location falls in a direct block row */ /* Or, if the offset has just filled up a direct or indirect block */ if(curr_offset == (col * hdr->man_dtable.row_block_size[row]) || row < hdr->man_dtable.max_direct_rows) { HDassert(curr_offset - (col * hdr->man_dtable.row_block_size[row]) == 0); break; /* Done now */ } /* end if */ /* Indirect block row */ else { H5HF_block_loc_t *new_loc; /* Pointer to new block location */ /* Allocate level structure */ if(NULL == (new_loc = H5FL_MALLOC(H5HF_block_loc_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for direct block free list section") /* Link new level into iterator */ new_loc->up = biter->curr; /* Adjust offset for new level */ offset = curr_offset - (col * hdr->man_dtable.row_block_size[row]); /* Make new block the current context */ biter->curr = new_loc; } /* end else */ } while(1); /* Breaks out in middle */ /* Set flag to indicate block iterator finished initializing */ biter->ready = TRUE; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5HF_man_iter_start_offset() */
/*-------------------------------------------------------------------------
* Function: H5O_layout_copy_file
*
* Purpose: Copies a message from _MESG to _DEST in file
*
* Return: Success: Ptr to _DEST
*
* Failure: NULL
*
* Programmer: Peter Cao
* July 23, 2005
*
*-------------------------------------------------------------------------
*/
static void *
H5O_layout_copy_file(H5F_t *file_src, void *mesg_src, H5F_t *file_dst,
hbool_t UNUSED *recompute_size, H5O_copy_t *cpy_info, void *_udata,
hid_t dxpl_id)
{
H5D_copy_file_ud_t *udata = (H5D_copy_file_ud_t *)_udata; /* Dataset copying user data */
H5O_layout_t *layout_src = (H5O_layout_t *) mesg_src;
H5O_layout_t *layout_dst = NULL;
hbool_t copied = FALSE; /* Whether the data was copied */
void *ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_layout_copy_file)
/* check args */
HDassert(file_src);
HDassert(layout_src);
HDassert(file_dst);
/* Allocate space for the destination layout */
if(NULL == (layout_dst = H5FL_MALLOC(H5O_layout_t)))
HGOTO_ERROR(H5E_OHDR, H5E_CANTALLOC, NULL, "memory allocation failed")
/* Copy the "top level" information */
*layout_dst = *layout_src;
/* Copy the layout type specific information */
switch(layout_src->type) {
case H5D_COMPACT:
if(layout_src->storage.u.compact.buf) {
/* copy compact raw data */
if(H5D_compact_copy(file_src, &layout_src->storage.u.compact, file_dst, &layout_dst->storage.u.compact, udata->src_dtype, cpy_info, dxpl_id) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy chunked storage")
copied = TRUE;
} /* end if */
break;
case H5D_CONTIGUOUS:
/* Compute the size of the contiguous storage for versions of the
* layout message less than version 3 because versions 1 & 2 would
* truncate the dimension sizes to 32-bits of information. - QAK 5/26/04
*/
if(layout_src->version < H5O_LAYOUT_VERSION_3)
layout_dst->storage.u.contig.size = H5S_extent_nelem(udata->src_space_extent) *
H5T_get_size(udata->src_dtype);
if(H5D_contig_is_space_alloc(&layout_src->storage)) {
/* copy contiguous raw data */
if(H5D_contig_copy(file_src, &layout_src->storage.u.contig, file_dst, &layout_dst->storage.u.contig, udata->src_dtype, cpy_info, dxpl_id) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy contiguous storage")
copied = TRUE;
} /* end if */
break;
case H5D_CHUNKED:
if(H5D_chunk_is_space_alloc(&layout_src->storage)) {
/* Create chunked layout */
if(H5D_chunk_copy(file_src, &layout_src->storage.u.chunk, &layout_src->u.chunk, file_dst, &layout_dst->storage.u.chunk, udata->src_space_extent, udata->src_dtype, udata->common.src_pline, cpy_info, dxpl_id) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy chunked storage")
copied = TRUE;
} /* end if */
break;
default:
HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "Invalid layout class")
} /* end switch */
/* Check if copy routine was invoked (which frees the source datatype) */
if(copied)
udata->src_dtype = NULL;
/* Set return value */
ret_value = layout_dst;
done:
if(!ret_value)
if(layout_dst)
layout_dst = H5FL_FREE(H5O_layout_t, layout_dst);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_layout_copy_file() */
/*------------------------------------------------------------------------- * Function: H5HF_man_dblock_create * * Purpose: Allocate & initialize a managed direct block * * Return: Pointer to new direct block on success, NULL on failure * * Programmer: Quincey Koziol * [email protected] * Feb 27 2006 * *------------------------------------------------------------------------- */ herr_t H5HF_man_dblock_create(hid_t dxpl_id, H5HF_hdr_t *hdr, H5HF_indirect_t *par_iblock, unsigned par_entry, haddr_t *addr_p, H5HF_free_section_t **ret_sec_node) { H5HF_free_section_t *sec_node; /* Pointer to free space section for block */ H5HF_direct_t *dblock = NULL; /* Pointer to direct block */ haddr_t dblock_addr; /* Direct block's address */ size_t free_space; /* Free space in new block */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5HF_man_dblock_create) /* * Check arguments. */ HDassert(hdr); /* * Allocate file and memory data structures. */ if(NULL == (dblock = H5FL_MALLOC(H5HF_direct_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for fractal heap direct block") /* Reset the metadata cache info for the heap header */ HDmemset(&dblock->cache_info, 0, sizeof(H5AC_info_t)); /* Share common heap information */ dblock->hdr = hdr; if(H5HF_hdr_incr(hdr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared heap header") /* Set info for direct block */ if(par_iblock) { unsigned par_row = par_entry / hdr->man_dtable.cparam.width; /* Row for block */ /* Compute offset & size, based on parent's information */ dblock->block_off = par_iblock->block_off; dblock->block_off += hdr->man_dtable.row_block_off[par_row]; dblock->block_off += hdr->man_dtable.row_block_size[par_row] * (par_entry % hdr->man_dtable.cparam.width); H5_ASSIGN_OVERFLOW(/* To: */ dblock->size, /* From: */ hdr->man_dtable.row_block_size[par_row], /* From: */ hsize_t, /* To: */ size_t); } /* end if */ else { /* Must be the root direct block */ dblock->block_off = 0; dblock->size = hdr->man_dtable.cparam.start_block_size; } /* end else */ dblock->blk_off_size = H5HF_SIZEOF_OFFSET_LEN(dblock->size); free_space = dblock->size - H5HF_MAN_ABS_DIRECT_OVERHEAD(hdr); /* Allocate buffer for block */ /* XXX: Change to using free-list factories */ if((dblock->blk = H5FL_BLK_MALLOC(direct_block, dblock->size)) == NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") #ifdef H5_CLEAR_MEMORY HDmemset(dblock->blk, 0, dblock->size); #endif /* H5_CLEAR_MEMORY */ /* Allocate space for the direct block on disk */ if(HADDR_UNDEF == (dblock_addr = H5MF_alloc(hdr->f, H5FD_MEM_FHEAP_DBLOCK, dxpl_id, (hsize_t)dblock->size))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap direct block") #ifdef QAK HDfprintf(stderr, "%s: direct block address = %a\n", FUNC, dblock_addr); #endif /* QAK */ /* Attach to parent indirect block, if there is one */ dblock->parent = par_iblock; if(dblock->parent) if(H5HF_man_iblock_attach(dblock->parent, par_entry, dblock_addr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTATTACH, FAIL, "can't attach direct block to parent indirect block") dblock->par_entry = par_entry; /* Create a new 'single' section for the free space in the block */ if(NULL == (sec_node = H5HF_sect_single_new((dblock->block_off + H5HF_MAN_ABS_DIRECT_OVERHEAD(hdr)), free_space, dblock->parent, dblock->par_entry))) HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't create section for new direct block's free space") /* Check what to do with section node */ if(ret_sec_node) /* Pass back the pointer to the section instead of adding it to the free list */ *ret_sec_node = sec_node; else { /* Add new free space to the heap's list of space */ if(H5HF_space_add(hdr, dxpl_id, sec_node, 0) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't add direct block free space to global list") } /* end else */ /* Cache the new fractal heap direct block */ if(H5AC_set(hdr->f, dxpl_id, H5AC_FHEAP_DBLOCK, dblock_addr, dblock, H5AC__NO_FLAGS_SET) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't add fractal heap direct block to cache") /* Increase the allocated heap size */ if(H5HF_hdr_inc_alloc(hdr, dblock->size) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't increase allocated heap size") /* Set the address of of direct block, if requested */ if(addr_p) *addr_p = dblock_addr; done: if(ret_value < 0) if(dblock) (void)H5HF_cache_dblock_dest(hdr->f, dblock); FUNC_LEAVE_NOAPI(ret_value) } /* end H5HF_man_dblock_create() */
/*------------------------------------------------------------------------- * Function: H5HF_man_dblock_create * * Purpose: Allocate & initialize a managed direct block * * Return: Pointer to new direct block on success, NULL on failure * * Programmer: Quincey Koziol * [email protected] * Feb 27 2006 * *------------------------------------------------------------------------- */ herr_t H5HF_man_dblock_create(hid_t dxpl_id, H5HF_hdr_t *hdr, H5HF_indirect_t *par_iblock, unsigned par_entry, haddr_t *addr_p, H5HF_free_section_t **ret_sec_node) { H5HF_free_section_t *sec_node; /* Pointer to free space section for block */ H5HF_direct_t *dblock = NULL; /* Pointer to direct block */ haddr_t dblock_addr; /* Direct block's address */ size_t free_space; /* Free space in new block */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT /* * Check arguments. */ HDassert(hdr); /* * Allocate file and memory data structures. */ if(NULL == (dblock = H5FL_MALLOC(H5HF_direct_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for fractal heap direct block") /* Reset the metadata cache info for the heap header */ HDmemset(&dblock->cache_info, 0, sizeof(H5AC_info_t)); /* Share common heap information */ dblock->hdr = hdr; if(H5HF_hdr_incr(hdr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared heap header") /* Set info for direct block */ if(par_iblock) { unsigned par_row = par_entry / hdr->man_dtable.cparam.width; /* Row for block */ /* Compute offset & size, based on parent's information */ dblock->block_off = par_iblock->block_off; dblock->block_off += hdr->man_dtable.row_block_off[par_row]; dblock->block_off += hdr->man_dtable.row_block_size[par_row] * (par_entry % hdr->man_dtable.cparam.width); H5_CHECKED_ASSIGN(dblock->size, size_t, hdr->man_dtable.row_block_size[par_row], hsize_t); } /* end if */ else { /* Must be the root direct block */ dblock->block_off = 0; dblock->size = hdr->man_dtable.cparam.start_block_size; } /* end else */ dblock->file_size = 0; free_space = dblock->size - H5HF_MAN_ABS_DIRECT_OVERHEAD(hdr); /* Allocate buffer for block */ /* XXX: Change to using free-list factories */ if((dblock->blk = H5FL_BLK_MALLOC(direct_block, dblock->size)) == NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") #ifdef H5_CLEAR_MEMORY HDmemset(dblock->blk, 0, dblock->size); #endif /* H5_CLEAR_MEMORY */ dblock->write_buf = NULL; dblock->write_size = 0; /* Allocate [temporary] space for the direct block on disk */ if(H5F_USE_TMP_SPACE(hdr->f)) { if(HADDR_UNDEF == (dblock_addr = H5MF_alloc_tmp(hdr->f, (hsize_t)dblock->size))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap direct block") } /* end if */ else { if(HADDR_UNDEF == (dblock_addr = H5MF_alloc(hdr->f, H5FD_MEM_FHEAP_DBLOCK, dxpl_id, (hsize_t)dblock->size)))
/*------------------------------------------------------------------------- * Function: H5HL_create * * Purpose: Creates a new heap data structure on disk and caches it * in memory. SIZE_HINT is a hint for the initial size of the * data area of the heap. If size hint is invalid then a * reasonable (but probably not optimal) size will be chosen. * If the heap ever has to grow, then REALLOC_HINT is the * minimum amount by which the heap will grow. * * Return: Success: Non-negative. The file address of new heap is * returned through the ADDR argument. * * Failure: Negative * * Programmer: Robb Matzke * [email protected] * Jul 16 1997 * *------------------------------------------------------------------------- */ herr_t H5HL_create(H5F_t *f, hid_t dxpl_id, size_t size_hint, haddr_t *addr_p/*out*/) { H5HL_t *heap = NULL; /* Heap created */ H5HL_prfx_t *prfx = NULL; /* Heap prefix */ hsize_t total_size; /* Total heap size on disk */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) /* check arguments */ HDassert(f); HDassert(addr_p); /* Adjust size hint as necessary */ if(size_hint && size_hint < H5HL_SIZEOF_FREE(f)) size_hint = H5HL_SIZEOF_FREE(f); size_hint = H5HL_ALIGN(size_hint); /* Allocate new heap structure */ if(NULL == (heap = H5HL_new(H5F_SIZEOF_SIZE(f), H5F_SIZEOF_ADDR(f), H5HL_SIZEOF_HDR(f)))) HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't allocate new heap struct") /* Allocate file space */ total_size = heap->prfx_size + size_hint; if(HADDR_UNDEF == (heap->prfx_addr = H5MF_alloc(f, H5FD_MEM_LHEAP, dxpl_id, total_size))) HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "unable to allocate file memory") /* Initialize info */ heap->single_cache_obj = TRUE; heap->dblk_addr = heap->prfx_addr + (hsize_t)heap->prfx_size; heap->dblk_size = size_hint; if(size_hint) if(NULL == (heap->dblk_image = H5FL_BLK_CALLOC(lheap_chunk, size_hint))) HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "memory allocation failed") /* free list */ if(size_hint) { if(NULL == (heap->freelist = H5FL_MALLOC(H5HL_free_t))) HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "memory allocation failed") heap->freelist->offset = 0; heap->freelist->size = size_hint; heap->freelist->prev = heap->freelist->next = NULL; heap->free_block = 0; } /* end if */ else { heap->freelist = NULL; heap->free_block = H5HL_FREE_NULL; } /* end else */ /* Allocate the heap prefix */ if(NULL == (prfx = H5HL_prfx_new(heap))) HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "memory allocation failed") /* Add to cache */ if(H5AC_insert_entry(f, dxpl_id, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "unable to cache local heap prefix") /* Set address to return */ *addr_p = heap->prfx_addr; done: if(ret_value < 0) { if(prfx) { if(H5HL_prfx_dest(prfx) < 0) HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy local heap prefix") } /* end if */ else { if(heap) { if(H5F_addr_defined(heap->prfx_addr)) if(H5MF_xfree(f, H5FD_MEM_LHEAP, dxpl_id, heap->prfx_addr, total_size) < 0) HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "can't release heap data?") if(H5HL_dest(heap) < 0) HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy local heap") } /* end if */ } /* end else */ } /* end if */
/*------------------------------------------------------------------------- * Function: H5B2_cache_hdr_load * * Purpose: Loads a B-tree header from the disk. * * Return: Success: Pointer to a new B-tree. * * Failure: NULL * * Programmer: Quincey Koziol * [email protected] * Feb 1 2005 * *------------------------------------------------------------------------- */ static H5B2_t * H5B2_cache_hdr_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_type, void UNUSED *udata) { const H5B2_class_t *type = (const H5B2_class_t *) _type; /* Type of B-tree */ unsigned depth; /* Depth of B-tree */ size_t node_size, rrec_size; /* Size info for B-tree */ uint8_t split_percent, merge_percent; /* Split & merge %s for B-tree */ H5B2_t *bt2 = NULL; /* B-tree info */ size_t size; /* Header size */ uint32_t stored_chksum; /* Stored metadata checksum value */ uint32_t computed_chksum; /* Computed metadata checksum value */ H5WB_t *wb = NULL; /* Wrapped buffer for header data */ uint8_t hdr_buf[H5B2_HDR_BUF_SIZE]; /* Buffer for header */ uint8_t *hdr; /* Pointer to header buffer */ uint8_t *p; /* Pointer into raw data buffer */ H5B2_t *ret_value; /* Return value */ FUNC_ENTER_NOAPI(H5B2_cache_hdr_load, NULL) /* Check arguments */ HDassert(f); HDassert(H5F_addr_defined(addr)); HDassert(type); /* Allocate space for the B-tree data structure */ if(NULL == (bt2 = H5FL_MALLOC(H5B2_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") HDmemset(&bt2->cache_info, 0, sizeof(H5AC_info_t)); /* Wrap the local buffer for serialized header info */ if(NULL == (wb = H5WB_wrap(hdr_buf, sizeof(hdr_buf)))) HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, NULL, "can't wrap buffer") /* Compute the size of the serialized B-tree header on disk */ size = H5B2_HEADER_SIZE(f); /* Get a pointer to a buffer that's large enough for header */ if(NULL == (hdr = (uint8_t *)H5WB_actual(wb, size))) HGOTO_ERROR(H5E_BTREE, H5E_NOSPACE, NULL, "can't get actual buffer") /* Read header from disk */ if(H5F_block_read(f, H5FD_MEM_BTREE, addr, size, dxpl_id, hdr) < 0) HGOTO_ERROR(H5E_BTREE, H5E_READERROR, NULL, "can't read B-tree header") /* Get temporary pointer to serialized header */ p = hdr; /* Magic number */ if(HDmemcmp(p, H5B2_HDR_MAGIC, (size_t)H5_SIZEOF_MAGIC)) HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, NULL, "wrong B-tree header signature") p += H5_SIZEOF_MAGIC; /* Version */ if(*p++ != H5B2_HDR_VERSION) HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, NULL, "wrong B-tree header version") /* B-tree type */ if(*p++ != (uint8_t)type->id) HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, NULL, "incorrect B-tree type") /* Node size (in bytes) */ UINT32DECODE(p, node_size); /* Raw key size (in bytes) */ UINT16DECODE(p, rrec_size); /* Depth of tree */ UINT16DECODE(p, depth); /* Split & merge %s */ split_percent = *p++; merge_percent = *p++; /* Root node pointer */ H5F_addr_decode(f, (const uint8_t **)&p, &(bt2->root.addr)); UINT16DECODE(p, bt2->root.node_nrec); H5F_DECODE_LENGTH(f, p, bt2->root.all_nrec); /* Metadata checksum */ UINT32DECODE(p, stored_chksum); /* Sanity check */ HDassert((size_t)(p - hdr) == size); /* Compute checksum on entire header */ computed_chksum = H5_checksum_metadata(hdr, (size - H5B2_SIZEOF_CHKSUM), 0); /* Verify checksum */ if(stored_chksum != computed_chksum) HGOTO_ERROR(H5E_BTREE, H5E_BADVALUE, NULL, "incorrect metadata checksum for v2 B-tree header") /* Initialize shared B-tree info */ if(H5B2_shared_init(f, bt2, type, depth, node_size, rrec_size, split_percent, merge_percent) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't create shared B-tree info") /* Set return value */ ret_value = bt2; done: /* Release resources */ if(wb && H5WB_unwrap(wb) < 0) HDONE_ERROR(H5E_BTREE, H5E_CLOSEERROR, NULL, "can't close wrapped buffer") if(!ret_value && bt2) (void)H5B2_cache_hdr_dest(f, bt2); FUNC_LEAVE_NOAPI(ret_value) } /* end H5B2_cache_hdr_load() */ /*lint !e818 Can't make udata a pointer to const */
/*------------------------------------------------------------------------- * Function: H5O_mtime_decode * * Purpose: Decode a modification time message and return a pointer to a * new time_t value. * * Return: Success: Ptr to new message in native struct. * * Failure: NULL * * Programmer: Robb Matzke * [email protected] * Jul 24 1998 * *------------------------------------------------------------------------- */ static void * H5O_mtime_decode(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, H5O_t UNUSED *open_oh, unsigned UNUSED mesg_flags, unsigned UNUSED *ioflags, const uint8_t *p) { time_t *mesg, the_time; int i; struct tm tm; void *ret_value; /* Return value */ FUNC_ENTER_NOAPI_NOINIT /* check args */ HDassert(f); HDassert(p); /* Initialize time zone information */ if(!ntzset) { HDtzset(); ntzset = TRUE; } /* end if */ /* decode */ for(i = 0; i < 14; i++) if(!HDisdigit(p[i])) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "badly formatted modification time message") /* * Convert YYYYMMDDhhmmss UTC to a time_t. This is a little problematic * because mktime() operates on local times. We convert to local time * and then figure out the adjustment based on the local time zone and * daylight savings setting. */ HDmemset(&tm, 0, sizeof tm); tm.tm_year = (p[0]-'0')*1000 + (p[1]-'0')*100 + (p[2]-'0')*10 + (p[3]-'0') - 1900; tm.tm_mon = (p[4]-'0')*10 + (p[5]-'0') - 1; tm.tm_mday = (p[6]-'0')*10 + (p[7]-'0'); tm.tm_hour = (p[8]-'0')*10 + (p[9]-'0'); tm.tm_min = (p[10]-'0')*10 + (p[11]-'0'); tm.tm_sec = (p[12]-'0')*10 + (p[13]-'0'); tm.tm_isdst = -1; /*figure it out*/ if((time_t)-1 == (the_time = HDmktime(&tm))) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "badly formatted modification time message") #if defined(H5_HAVE_TM_GMTOFF) /* FreeBSD, OSF 4.0 */ the_time += tm.tm_gmtoff; #elif defined(H5_HAVE___TM_GMTOFF) /* Linux libc-4 */ the_time += tm.__tm_gmtoff; #elif defined(H5_HAVE_TIMEZONE) #if _MSC_VER >= 1900 long timezone = 0; _get_timezone(&timezone); #endif /* Linux libc-5 */ the_time -= timezone - (tm.tm_isdst?3600:0); #elif defined(H5_HAVE_BSDGETTIMEOFDAY) && defined(H5_HAVE_STRUCT_TIMEZONE) /* Irix5.3 */ { struct timezone tz; if(HDBSDgettimeofday(NULL, &tz) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "unable to obtain local timezone information") the_time -= tz.tz_minuteswest * 60 - (tm.tm_isdst ? 3600 : 0); } #elif defined(H5_HAVE_GETTIMEOFDAY) && defined(H5_HAVE_STRUCT_TIMEZONE) && defined(H5_GETTIMEOFDAY_GIVES_TZ) { struct timezone tz; struct timeval tv; /* Used as a placebo; some systems don't like NULL */ if(HDgettimeofday(&tv, &tz) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "unable to obtain local timezone information") the_time -= tz.tz_minuteswest * 60 - (tm.tm_isdst ? 3600 : 0); } #else /* * The catch-all. If we can't convert a character string universal * coordinated time to a time_t value reliably then we can't decode the * modification time message. This really isn't as bad as it sounds -- the * only way a user can get the modification time is from our internal * query routines, which can gracefully recover. */ /* Irix64 */ HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "unable to obtain local timezone information") #endif /* The return value */ if(NULL == (mesg = H5FL_MALLOC(time_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") *mesg = the_time; /* Set return value */ ret_value = mesg; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5O_mtime_decode() */
/*-------------------------------------------------------------------------
* Function: H5I_register
*
* Purpose: Registers an OBJECT in a GROUP and returns an ID for it.
* This routine does _not_ check for unique-ness of the objects,
* if you register an object twice, you will get two different
* IDs for it. This routine does make certain that each ID in a
* group is unique. IDs are created by getting a unique number
* for the group the ID is in and incorporating the group into
* the ID which is returned to the user.
*
* Return: Success: New object id.
*
* Failure: Negative
*
* Programmer: Unknown
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
hid_t
H5I_register(H5I_type_t grp, void *object)
{
H5I_id_group_t *grp_ptr=NULL; /*ptr to the group */
H5I_id_info_t *id_ptr=NULL; /*ptr to the new ID information */
hid_t new_id; /*new ID */
unsigned hash_loc; /*new item's hash table location*/
hid_t next_id; /*next ID to check */
hid_t ret_value=SUCCEED; /*return value */
H5I_id_info_t *curr_id; /*ptr to the current atom */
unsigned i; /*counter */
FUNC_ENTER_NOAPI(H5I_register, FAIL);
/* Check arguments */
if (grp <= H5I_BADID || grp >= H5I_NGROUPS)
HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid group number");
grp_ptr = H5I_id_group_list_g[grp];
if (grp_ptr == NULL || grp_ptr->count <= 0)
HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid group");
if ((id_ptr = H5FL_MALLOC(H5I_id_info_t)) == NULL)
HGOTO_ERROR(H5E_ATOM, H5E_NOSPACE, FAIL, "memory allocation failed");
/* Create the struct & it's ID */
new_id = H5I_MAKE(grp, grp_ptr->nextid);
id_ptr->id = new_id;
id_ptr->count = 1; /*initial reference count*/
id_ptr->obj_ptr = object;
id_ptr->next = NULL;
/* hash bucket already full, prepend to front of chain */
hash_loc = grp_ptr->nextid % (unsigned) grp_ptr->hash_size;
if (grp_ptr->id_list[hash_loc] != NULL)
id_ptr->next = grp_ptr->id_list[hash_loc];
/* Insert into the group */
grp_ptr->id_list[hash_loc] = id_ptr;
grp_ptr->ids++;
grp_ptr->nextid++;
/*
* This next section of code checks for the 'nextid' getting too large and
* wrapping around, thus necessitating checking for duplicate IDs being
* handed out.
*/
if (grp_ptr->nextid > (unsigned)ID_MASK) {
grp_ptr->wrapped = 1;
grp_ptr->nextid = grp_ptr->reserved;
}
/*
* If we've wrapped around then we need to check for duplicate id's being
* handed out.
*/
if (grp_ptr->wrapped) {
/*
* Make sure we check all available ID's. If we're about at the end
* of the range then wrap around and check the beginning values. If
* we check all possible values and didn't find any free ones *then*
* we can fail.
*/
for (i=grp_ptr->reserved; i<ID_MASK; i++) {
/* Handle end of range by wrapping to beginning */
if (grp_ptr->nextid>(unsigned)ID_MASK)
grp_ptr->nextid = grp_ptr->reserved;
/* new ID to check for */
next_id = H5I_MAKE(grp, grp_ptr->nextid);
hash_loc = H5I_LOC (grp_ptr->nextid, grp_ptr->hash_size);
curr_id = grp_ptr->id_list[hash_loc];
if (curr_id == NULL)
break; /* Ha! this is not likely... */
while (curr_id) {
if (curr_id->id == next_id)
break;
curr_id = curr_id->next;
}
if (!curr_id)
break; /* must not have found a match */
grp_ptr->nextid++;
}
if (i>=(unsigned)ID_MASK)
/* All the IDs are gone! */
HGOTO_ERROR(H5E_ATOM, H5E_NOIDS, FAIL, "no IDs available in group");
}
ret_value = new_id;
done:
FUNC_LEAVE_NOAPI(ret_value);
}
