summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/H5F.c3
-rw-r--r--src/H5Fprivate.h3
-rw-r--r--src/H5G.c59
-rw-r--r--src/H5Gent.c6
-rw-r--r--src/H5Gnode.c238
-rw-r--r--src/H5HL.c625
-rw-r--r--src/H5HLprivate.h7
-rw-r--r--src/H5MF.c143
-rw-r--r--src/H5MFprivate.h4
-rw-r--r--src/H5O.c71
-rw-r--r--src/H5Oefl.c53
-rw-r--r--src/H5Oprivate.h22
-rw-r--r--src/H5private.h74
-rw-r--r--test/lheap.c21
-rwxr-xr-xtest/reserved.c273
-rw-r--r--test/titerate.c59
-rw-r--r--test/unlink.c2
17 files changed, 1004 insertions, 659 deletions
diff --git a/src/H5F.c b/src/H5F.c
index 4a2f07e..e8c98e9 100644
--- a/src/H5F.c
+++ b/src/H5F.c
@@ -4551,7 +4551,6 @@ H5F_get_eoa(const H5F_t *f)
{
haddr_t ret_value;
- /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
FUNC_ENTER_NOAPI(H5F_get_eoa, HADDR_UNDEF)
assert(f);
@@ -4563,7 +4562,7 @@ H5F_get_eoa(const H5F_t *f)
done:
FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5F_get_base_addr() */
+} /* end H5F_get_eoa() */
#ifdef H5_HAVE_PARALLEL
diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index 83b8b57..695c3bc 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -213,6 +213,8 @@ typedef struct H5F_t H5F_t;
#define H5F_HAS_FEATURE(F,FL) ((F)->shared->lf->feature_flags&(FL))
/* B-tree node raw page */
#define H5F_GRP_BTREE_SHARED(F) ((F)->shared->grp_btree_shared)
+/* Base address of file */
+#define H5F_BASE_ADDR(F) ((F)->shared->base_addr)
#else /* H5F_PACKAGE */
#define H5F_SIZEOF_ADDR(F) (H5F_sizeof_addr(F))
#define H5F_SIZEOF_SIZE(F) (H5F_sizeof_size(F))
@@ -223,6 +225,7 @@ typedef struct H5F_t H5F_t;
#define H5F_RDCC_W0(F) (H5F_rdcc_w0(F))
#define H5F_HAS_FEATURE(F,FL) (H5F_has_feature(F,FL))
#define H5F_GRP_BTREE_SHARED(F) (H5F_grp_btree_shared(F))
+#define H5F_BASE_ADDR(F) (H5F_base_addr(F))
#endif /* H5F_PACKAGE */
diff --git a/src/H5G.c b/src/H5G.c
index 8ab9c59..db79d98 100644
--- a/src/H5G.c
+++ b/src/H5G.c
@@ -996,9 +996,9 @@ H5G_init_interface(void)
/*
* Initialize the type info table. Begin with the most general types and
* end with the most specific. For instance, any object that has a data
- * type message is a data type but only some of them are datasets.
+ * type message is a datatype but only some of them are datasets.
*/
- H5G_register_type(H5G_TYPE, H5T_isa, "data type");
+ H5G_register_type(H5G_TYPE, H5T_isa, "datatype");
H5G_register_type(H5G_GROUP, H5G_isa, "group");
H5G_register_type(H5G_DATASET, H5D_isa, "dataset");
H5G_register_type(H5G_LINK, H5G_link_isa, "link");
@@ -1596,6 +1596,7 @@ H5G_traverse_slink (H5G_entry_t *grp_ent/*in,out*/,
char *linkval = NULL; /*the copied link value */
H5G_entry_t tmp_grp_ent; /* Temporary copy of group entry */
H5RS_str_t *tmp_user_path_r=NULL, *tmp_canon_path_r=NULL; /* Temporary pointer to object's user path & canonical path */
+ const H5HL_t *heap;
herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5G_traverse_slink, FAIL);
@@ -1606,10 +1607,17 @@ H5G_traverse_slink (H5G_entry_t *grp_ent/*in,out*/,
/* Get the link value */
if (NULL==H5O_read (grp_ent, H5O_STAB_ID, 0, &stab_mesg, dxpl_id))
HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "unable to determine local heap address");
- if (NULL==(clv=H5HL_peek (grp_ent->file, dxpl_id, stab_mesg.heap_addr,
- obj_ent->cache.slink.lval_offset)))
- HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read symbolic link value");
+
+ if (NULL == (heap = H5HL_protect(grp_ent->file, dxpl_id, stab_mesg.heap_addr)))
+ HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read protect link value")
+
+ clv = H5HL_offset_into(grp_ent->file, heap, obj_ent->cache.slink.lval_offset);
+
linkval = H5MM_xstrdup (clv);
+ assert(linkval);
+
+ if (H5HL_unprotect(grp_ent->file, dxpl_id, heap, stab_mesg.heap_addr) < 0)
+ HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read unprotect link value")
/* Hold the entry's name (& old_name) to restore later */
tmp_user_path_r=obj_ent->user_path_r;
@@ -1842,7 +1850,7 @@ H5G_isa(H5G_entry_t *ent, hid_t dxpl_id)
{
htri_t ret_value;
- FUNC_ENTER_NOAPI(H5G_isa, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT(H5G_isa);
assert(ent);
@@ -2340,12 +2348,8 @@ H5G_loc (hid_t loc_id)
case H5I_TEMPBUF:
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "unable to get symbol table entry of buffer");
-
- case H5I_NGROUPS:
- case H5I_BADID:
- case H5I_FILE_CLOSING:
- case H5I_REFERENCE:
- case H5I_VFL:
+
+ default:
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid object ID");
}
@@ -2581,12 +2585,21 @@ H5G_get_objinfo (H5G_entry_t *loc, const char *name, hbool_t follow_link,
*/
if (statbuf) {
if (H5G_CACHED_SLINK==obj_ent.type) {
+ const H5HL_t *heap;
+
/* Named object is a symbolic link */
- if (NULL==H5O_read (&grp_ent, H5O_STAB_ID, 0, &stab_mesg, dxpl_id) ||
- NULL==(s=H5HL_peek (grp_ent.file, dxpl_id, stab_mesg.heap_addr,
- obj_ent.cache.slink.lval_offset)))
- HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to read symbolic link value");
- statbuf->linklen = HDstrlen(s)+1; /*count the null terminator*/
+ if (NULL == H5O_read(&grp_ent, H5O_STAB_ID, 0, &stab_mesg, dxpl_id))
+ HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to read symbolic link value")
+
+ if (NULL == (heap = H5HL_protect(grp_ent.file, dxpl_id, stab_mesg.heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read protect link value")
+
+ s = H5HL_offset_into(grp_ent.file, heap, obj_ent.cache.slink.lval_offset);
+
+ statbuf->linklen = HDstrlen(s) + 1; /*count the null terminator*/
+
+ if (H5HL_unprotect(grp_ent.file, dxpl_id, heap, stab_mesg.heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read unprotect link value")
statbuf->objno[0] = statbuf->objno[1] = 0;
statbuf->nlink = 0;
statbuf->type = H5G_LINK;
@@ -2810,6 +2823,7 @@ H5G_linkval (H5G_entry_t *loc, const char *name, size_t size, char *buf/*out*/,
const char *s = NULL;
H5G_entry_t grp_ent, obj_ent;
H5O_stab_t stab_mesg;
+ const H5HL_t *heap;
herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5G_linkval, FAIL);
@@ -2830,14 +2844,19 @@ H5G_linkval (H5G_entry_t *loc, const char *name, size_t size, char *buf/*out*/,
*/
if (NULL==H5O_read (&grp_ent, H5O_STAB_ID, 0, &stab_mesg, dxpl_id))
HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to determine local heap address");
- if (NULL==(s=H5HL_peek (grp_ent.file, dxpl_id, stab_mesg.heap_addr,
- obj_ent.cache.slink.lval_offset)))
- HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to read symbolic link value");
+
+ if (NULL == (heap = H5HL_protect(grp_ent.file, dxpl_id, stab_mesg.heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read protect link value")
+ s = H5HL_offset_into(grp_ent.file, heap, obj_ent.cache.slink.lval_offset);
+
/* Copy to output buffer */
if (size>0 && buf)
HDstrncpy (buf, s, size);
+ if (H5HL_unprotect(grp_ent.file, dxpl_id, heap, stab_mesg.heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read unprotect link value")
+
done:
/* Free the ID to name buffers */
H5G_free_ent_name(&grp_ent);
diff --git a/src/H5Gent.c b/src/H5Gent.c
index b050453..4d9fe62 100644
--- a/src/H5Gent.c
+++ b/src/H5Gent.c
@@ -501,10 +501,14 @@ H5G_ent_debug(H5F_t UNUSED *f, hid_t dxpl_id, const H5G_entry_t *ent, FILE * str
"Link value offset:",
(unsigned long)(ent->cache.slink.lval_offset));
if (heap>0 && H5F_addr_defined(heap)) {
- lval = H5HL_peek (ent->file, dxpl_id, heap, ent->cache.slink.lval_offset);
+ const H5HL_t *heap_ptr;
+
+ heap_ptr = H5HL_protect(ent->file, dxpl_id, heap);
+ lval = H5HL_offset_into(ent->file, heap_ptr, ent->cache.slink.lval_offset);
HDfprintf (stream, "%*s%-*s %s\n", nested_indent, "", nested_fwidth,
"Link value:",
lval);
+ H5HL_unprotect(ent->file, dxpl_id, heap_ptr, heap);
}
else
HDfprintf(stream, "%*s%-*s\n", nested_indent, "", nested_fwidth, "Warning: Invalid heap address given, name not displayed!");
diff --git a/src/H5Gnode.c b/src/H5Gnode.c
index 851de13..eaa0089 100644
--- a/src/H5Gnode.c
+++ b/src/H5Gnode.c
@@ -300,20 +300,27 @@ H5G_node_debug_key (FILE *stream, H5F_t *f, hid_t dxpl_id, int indent, int fwidt
{
const H5G_node_key_t *key = (const H5G_node_key_t *) _key;
const H5G_bt_ud1_t *udata = (const H5G_bt_ud1_t *) _udata;
+ const H5HL_t *heap = NULL;
const char *s;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5G_node_debug_key, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT(H5G_node_debug_key);
assert (key);
HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Heap offset:",
(unsigned)key->offset);
HDfprintf(stream, "%*s%-*s ", indent, "", fwidth, "Name:");
- if (NULL == (s = H5HL_peek(f, dxpl_id, udata->heap_addr, key->offset)))
- HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read symbol name");
+
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, udata->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to protect symbol name");
+
+ s = H5HL_offset_into(f, heap, key->offset);
HDfprintf (stream, "%s\n", s);
+ if (H5HL_unprotect(f, dxpl_id, heap, udata->heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol name");
+
done:
FUNC_LEAVE_NOAPI(ret_value);
}
@@ -378,7 +385,7 @@ H5G_node_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *_udata1
const uint8_t *p = NULL;
H5G_node_t *ret_value; /*for error handling */
- FUNC_ENTER_NOAPI(H5G_node_load, NULL);
+ FUNC_ENTER_NOAPI_NOINIT(H5G_node_load);
/*
* Check arguments.
@@ -469,7 +476,7 @@ H5G_node_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5G_node_
int i;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5G_node_flush, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT(H5G_node_flush);
/*
* Check arguments.
@@ -755,19 +762,22 @@ H5G_node_cmp2(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata, void *_rt_ke
H5G_bt_ud1_t *udata = (H5G_bt_ud1_t *) _udata;
H5G_node_key_t *lt_key = (H5G_node_key_t *) _lt_key;
H5G_node_key_t *rt_key = (H5G_node_key_t *) _rt_key;
+ const H5HL_t *heap = NULL;
const char *s1, *s2;
const char *base; /* Base of heap */
int ret_value;
- FUNC_ENTER_NOAPI(H5G_node_cmp2, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT(H5G_node_cmp2);
assert(udata);
assert(lt_key);
assert(rt_key);
/* Get base address of heap */
- if (NULL == (base = H5HL_peek(f, dxpl_id, udata->heap_addr, 0)))
- HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read symbol name");
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, udata->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to protect symbol name");
+
+ base = H5HL_offset_into(f, heap, 0);
/* Get pointers to string names */
s1=base+lt_key->offset;
@@ -777,6 +787,9 @@ H5G_node_cmp2(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata, void *_rt_ke
ret_value = HDstrcmp(s1, s2);
done:
+ if (heap && H5HL_unprotect(f, dxpl_id, heap, udata->heap_addr) < 0)
+ HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol name");
+
FUNC_LEAVE_NOAPI(ret_value);
}
@@ -814,15 +827,18 @@ H5G_node_cmp3(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata, void *_rt_ke
H5G_bt_ud1_t *udata = (H5G_bt_ud1_t *) _udata;
H5G_node_key_t *lt_key = (H5G_node_key_t *) _lt_key;
H5G_node_key_t *rt_key = (H5G_node_key_t *) _rt_key;
+ const H5HL_t *heap = NULL;
const char *s;
const char *base; /* Base of heap */
int ret_value=0; /* Return value */
- FUNC_ENTER_NOAPI(H5G_node_cmp3, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT(H5G_node_cmp3);
/* Get base address of heap */
- if (NULL == (base = H5HL_peek(f, dxpl_id, udata->heap_addr, 0)))
- HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read symbol name");
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, udata->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to protect symbol name");
+
+ base = H5HL_offset_into(f, heap, 0);
/* left side */
s=base+lt_key->offset;
@@ -835,6 +851,9 @@ H5G_node_cmp3(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata, void *_rt_ke
HGOTO_DONE(1);
done:
+ if (heap && H5HL_unprotect(f, dxpl_id, heap, udata->heap_addr) < 0)
+ HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol name");
+
FUNC_LEAVE_NOAPI(ret_value);
}
@@ -874,12 +893,13 @@ H5G_node_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *_lt_key
{
H5G_bt_ud1_t *bt_udata = (H5G_bt_ud1_t *) _udata;
H5G_node_t *sn = NULL;
+ const H5HL_t *heap = NULL;
int lt = 0, idx = 0, rt, cmp = 1;
const char *s;
const char *base; /* Base of heap */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5G_node_found, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT(H5G_node_found);
/*
* Check arguments.
@@ -895,8 +915,10 @@ H5G_node_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *_lt_key
HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, FAIL, "unable to protect symbol table node");
/* Get base address of heap */
- if (NULL == (base = H5HL_peek(f, dxpl_id, bt_udata->heap_addr, 0)))
- HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to read symbol name");
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, bt_udata->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to protect symbol name");
+
+ base = H5HL_offset_into(f, heap, 0);
/*
* Binary search.
@@ -913,20 +935,25 @@ H5G_node_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *_lt_key
lt = idx + 1;
}
}
+
+ if (H5HL_unprotect(f, dxpl_id, heap, bt_udata->heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol name");
+ heap=NULL; base=NULL;
+
if (cmp)
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "not found");
if (bt_udata->operation==H5G_OPER_FIND)
/*
- * The caller is querying the symbol entry. Return just a pointer to
- * the entry. The pointer is valid until the next call to H5AC.
+ * The caller is querying the symbol entry, copy it into the UDATA
+ * entry field. (Hmm... should this use H5G_ent_copy()? - QAK)
*/
bt_udata->ent = sn->entry[idx];
else
HGOTO_ERROR(H5E_SYM, H5E_UNSUPPORTED, FAIL, "internal erorr (unknown symbol find operation)");
done:
- if (sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, FALSE) < 0 && ret_value>=0)
+ if (sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, FALSE) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to release symbol table node");
FUNC_LEAVE_NOAPI(ret_value);
@@ -981,6 +1008,7 @@ H5G_node_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void UNUSED *_lt_key,
H5G_bt_ud1_t *bt_udata = (H5G_bt_ud1_t *) _udata;
H5G_node_t *sn = NULL, *snrt = NULL;
+ const H5HL_t *heap = NULL;
size_t offset; /*offset of name in heap */
const char *s;
const char *base; /* Base of heap */
@@ -989,7 +1017,7 @@ H5G_node_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void UNUSED *_lt_key,
H5G_node_t *insert_into = NULL; /*node that gets new entry*/
H5B_ins_t ret_value = H5B_INS_ERROR;
- FUNC_ENTER_NOAPI(H5G_node_insert, H5B_INS_ERROR);
+ FUNC_ENTER_NOAPI_NOINIT(H5G_node_insert);
/*
* Check arguments.
@@ -1008,8 +1036,10 @@ H5G_node_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void UNUSED *_lt_key,
HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR, "unable to protect symbol table node");
/* Get base address of heap */
- if (NULL == (base = H5HL_peek(f, dxpl_id, bt_udata->heap_addr, 0)))
- HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_INS_ERROR, "unable to read symbol name");
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, bt_udata->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_INS_ERROR, "unable to protect symbol name");
+
+ base = H5HL_offset_into(f, heap, 0);
/*
* Where does the new symbol get inserted? We use a binary search.
@@ -1018,8 +1048,17 @@ H5G_node_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void UNUSED *_lt_key,
while (lt < rt) {
idx = (lt + rt) / 2;
s=base+sn->entry[idx].name_off;
- if (0 == (cmp = HDstrcmp(bt_udata->name, s))) /*already present */
- HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, H5B_INS_ERROR, "symbol is already present in symbol table");
+
+ if (0 == (cmp = HDstrcmp(bt_udata->name, s))) /*already present */ {
+ HCOMMON_ERROR(H5E_SYM, H5E_CANTINSERT, "symbol is already present in symbol table");
+
+ if (H5HL_unprotect(f, dxpl_id, heap, bt_udata->heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to unprotect symbol name");
+ heap=NULL; base=NULL;
+
+ HGOTO_DONE(H5B_INS_ERROR);
+ }
+
if (cmp < 0) {
rt = idx;
} else {
@@ -1028,6 +1067,10 @@ H5G_node_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void UNUSED *_lt_key,
}
idx += cmp > 0 ? 1 : 0;
+ if (H5HL_unprotect(f, dxpl_id, heap, bt_udata->heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to unprotect symbol name");
+ heap=NULL; base=NULL;
+
/*
* Add the new name to the heap.
*/
@@ -1156,12 +1199,13 @@ H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
H5G_node_key_t *rt_key = (H5G_node_key_t*)_rt_key;
H5G_bt_ud1_t *bt_udata = (H5G_bt_ud1_t*)_udata;
H5G_node_t *sn = NULL;
+ const H5HL_t *heap = NULL;
int lt=0, rt, idx=0, cmp=1;
const char *s = NULL;
const char *base; /* Base of heap */
H5B_ins_t ret_value = H5B_INS_ERROR;
- FUNC_ENTER_NOAPI(H5G_node_remove, H5B_INS_ERROR);
+ FUNC_ENTER_NOAPI_NOINIT(H5G_node_remove);
/* Check arguments */
assert(f);
@@ -1174,12 +1218,17 @@ H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
if (NULL==(sn=H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL)))
HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR, "unable to protect symbol table node");
- /* Get base address of heap */
- if (NULL == (base = H5HL_peek(f, dxpl_id, bt_udata->heap_addr, 0)))
- HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_INS_ERROR, "unable to read symbol name");
-
/* "Normal" removal of a single entry from the symbol table node */
if(bt_udata->name!=NULL) {
+ size_t len=0;
+ hbool_t found; /* Indicate that the string was found */
+
+ /* Get base address of heap */
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, bt_udata->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_INS_ERROR, "unable to protect symbol name");
+
+ base = H5HL_offset_into(f, heap, 0);
+
/* Find the name with a binary search */
rt = sn->nsyms;
while (lt<rt && cmp) {
@@ -1192,14 +1241,35 @@ H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
lt = idx+1;
}
}
+
+ if (H5HL_unprotect(f, dxpl_id, heap, bt_udata->heap_addr) < 0)
+ HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to unprotect symbol name");
+ heap=NULL; base=NULL;
+
if (cmp)
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_INS_ERROR, "not found");
if (H5G_CACHED_SLINK==sn->entry[idx].type) {
/* Remove the symbolic link value */
- if ((s=H5HL_peek(f, dxpl_id, bt_udata->heap_addr, sn->entry[idx].cache.slink.lval_offset)))
- H5HL_remove(f, dxpl_id, bt_udata->heap_addr, sn->entry[idx].cache.slink.lval_offset, HDstrlen(s)+1);
- H5E_clear(); /*no big deal*/
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, bt_udata->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_INS_ERROR, "unable to protect symbol name");
+
+ s = H5HL_offset_into(f, heap, sn->entry[idx].cache.slink.lval_offset);
+ if (s) {
+ len=HDstrlen(s)+1;
+ found=1;
+ } /* end if */
+ else
+ found=0;
+
+ if (H5HL_unprotect(f, dxpl_id, heap, bt_udata->heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to unprotect symbol name");
+ heap=NULL; s=NULL;
+
+ if (found)
+ H5HL_remove(f, dxpl_id, bt_udata->heap_addr, sn->entry[idx].cache.slink.lval_offset, len);
+
+ H5E_clear(); /* no big deal */
} else {
/* Decrement the reference count */
assert(H5F_addr_defined(sn->entry[idx].header));
@@ -1208,9 +1278,26 @@ H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
}
/* Remove the name from the local heap */
- if ((s=H5HL_peek(f, dxpl_id, bt_udata->heap_addr, sn->entry[idx].name_off)))
- H5HL_remove(f, dxpl_id, bt_udata->heap_addr, sn->entry[idx].name_off, HDstrlen(s)+1);
- H5E_clear(); /*no big deal*/
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, bt_udata->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_INS_ERROR, "unable to protect symbol name");
+
+ s = H5HL_offset_into(f, heap, sn->entry[idx].name_off);
+
+ if (s) {
+ len=HDstrlen(s)+1;
+ found=1;
+ } /* end if */
+ else
+ found=0;
+
+ if (H5HL_unprotect(f, dxpl_id, heap, bt_udata->heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to unprotect symbol name");
+ heap=NULL; s=NULL;
+
+ if (found)
+ H5HL_remove(f, dxpl_id, bt_udata->heap_addr, sn->entry[idx].name_off, len);
+
+ H5E_clear(); /* no big deal */
/* Remove the entry from the symbol table node */
if (1==sn->nsyms) {
@@ -1301,7 +1388,7 @@ H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
} /* end else */
done:
- if (sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, FALSE)<0 && ret_value!=H5B_INS_ERROR)
+ if (sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, FALSE)<0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to release symbol table node");
FUNC_LEAVE_NOAPI(ret_value);
@@ -1333,6 +1420,7 @@ H5G_node_iterate (H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
{
H5G_bt_ud2_t *bt_udata = (H5G_bt_ud2_t *)_udata;
H5G_node_t *sn = NULL;
+ const H5HL_t *heap = NULL;
int i, nsyms;
size_t n, *name_off=NULL;
const char *name;
@@ -1352,14 +1440,20 @@ H5G_node_iterate (H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
* Save information about the symbol table node since we can't lock it
* because we're about to call an application function.
*/
- if (NULL == (sn = H5AC_find(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL)))
+ if (NULL == (sn = H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL)))
HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_ITER_ERROR, "unable to load symbol table node");
nsyms = sn->nsyms;
if (NULL==(name_off = H5MM_malloc (nsyms*sizeof(name_off[0]))))
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, H5B_ITER_ERROR, "memory allocation failed");
for (i=0; i<nsyms; i++)
name_off[i] = sn->entry[i].name_off;
- sn = NULL;
+
+ if (H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, FALSE) != SUCCEED) {
+ sn = NULL;
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to release object header");
+ }
+
+ sn=NULL; /* Make certain future references will be caught */
/*
* Iterate over the symbol table node entries.
@@ -1368,7 +1462,10 @@ H5G_node_iterate (H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
if (bt_udata->skip>0) {
--bt_udata->skip;
} else {
- name = H5HL_peek (f, dxpl_id, bt_udata->ent->cache.stab.heap_addr, name_off[i]);
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, bt_udata->ent->cache.stab.heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_ITER_ERROR, "unable to protect symbol name");
+
+ name = H5HL_offset_into(f, heap, name_off[i]);
assert (name);
n = HDstrlen (name);
@@ -1379,6 +1476,11 @@ H5G_node_iterate (H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
s = buf;
}
HDstrcpy (s, name);
+
+ if (H5HL_unprotect(f, dxpl_id, heap, bt_udata->ent->cache.stab.heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to unprotect symbol name");
+ heap=NULL; name=NULL;
+
ret_value = (bt_udata->op)(bt_udata->group_id, s, bt_udata->op_data);
if (s!=buf)
H5MM_xfree (s);
@@ -1392,6 +1494,12 @@ H5G_node_iterate (H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
HERROR (H5E_SYM, H5E_CANTNEXT, "iteration operator failed");
done:
+ if (heap && H5HL_unprotect(f, dxpl_id, heap, bt_udata->ent->cache.stab.heap_addr) < 0)
+ HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to unprotect symbol name");
+
+ if (sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, FALSE) != SUCCEED)
+ HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to release object header");
+
name_off = H5MM_xfree (name_off);
FUNC_LEAVE_NOAPI(ret_value);
}
@@ -1430,12 +1538,15 @@ H5G_node_sumup(H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
assert(num_objs);
/* Find the object node and add the number of symbol entries. */
- if (NULL == (sn = H5AC_find(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL)))
+ if (NULL == (sn = H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL)))
HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_ITER_ERROR, "unable to load symbol table node");
*num_objs += sn->nsyms;
done:
+ if (sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, FALSE) != SUCCEED)
+ HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to release object header");
+
FUNC_LEAVE_NOAPI(ret_value);
}
@@ -1461,6 +1572,7 @@ H5G_node_name(H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
void UNUSED *_rt_key, void *_udata)
{
H5G_bt_ud3_t *bt_udata = (H5G_bt_ud3_t *)_udata;
+ const H5HL_t *heap = NULL;
size_t name_off;
hsize_t loc_idx;
const char *name;
@@ -1476,23 +1588,35 @@ H5G_node_name(H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
assert(H5F_addr_defined(addr));
assert(bt_udata);
-
- if (NULL == (sn = H5AC_find(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL)))
+ if (NULL == (sn = H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL)))
HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_ITER_ERROR, "unable to load symbol table node");
/* Find the node, locate the object symbol table entry and retrieve the name */
if(bt_udata->idx >= bt_udata->num_objs && bt_udata->idx < (bt_udata->num_objs+sn->nsyms)) {
loc_idx = bt_udata->idx - bt_udata->num_objs;
name_off = sn->entry[loc_idx].name_off;
- name = H5HL_peek (f, dxpl_id, bt_udata->ent->cache.stab.heap_addr, name_off);
+
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, bt_udata->ent->cache.stab.heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_ITER_ERROR, "unable to protect symbol name");
+
+ name = H5HL_offset_into(f, heap, name_off);
assert (name);
bt_udata->name = H5MM_strdup (name);
- HGOTO_DONE(H5B_ITER_STOP);
- }
+ assert(bt_udata->name);
- bt_udata->num_objs += sn->nsyms;
+ if (H5HL_unprotect(f, dxpl_id, heap, bt_udata->ent->cache.stab.heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to unprotect symbol name");
+ heap=NULL; name=NULL;
+
+ ret_value = H5B_ITER_STOP;
+ } else {
+ bt_udata->num_objs += sn->nsyms;
+ }
done:
+ if (sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, FALSE) != SUCCEED)
+ HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to release object header");
+
FUNC_LEAVE_NOAPI(ret_value);
}
@@ -1529,7 +1653,7 @@ H5G_node_type(H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
assert(bt_udata);
/* Find the node, locate the object symbol table entry and retrieve the type */
- if (NULL == (sn = H5AC_find(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL)))
+ if (NULL == (sn = H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL)))
HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_ITER_ERROR, "unable to load symbol table node");
if(bt_udata->idx >= bt_udata->num_objs && bt_udata->idx < (bt_udata->num_objs+sn->nsyms)) {
@@ -1539,8 +1663,11 @@ H5G_node_type(H5F_t *f, hid_t dxpl_id, void UNUSED *_lt_key, haddr_t addr,
} else {
bt_udata->num_objs += sn->nsyms;
}
-
+
done:
+ if (sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, FALSE) != SUCCEED)
+ HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to release object header");
+
FUNC_LEAVE_NOAPI(ret_value);
}
@@ -1691,6 +1818,7 @@ H5G_node_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent,
int i;
H5G_node_t *sn = NULL;
const char *s;
+ const H5HL_t *heap_ptr = NULL;
herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5G_node_debug, FAIL);
@@ -1731,11 +1859,19 @@ H5G_node_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent,
fwidth = MAX(0, fwidth - 3);
for (i = 0; i < sn->nsyms; i++) {
fprintf(stream, "%*sSymbol %d:\n", indent - 3, "", i);
- if (heap>0 && H5F_addr_defined(heap) &&
- (s = H5HL_peek(f, dxpl_id, heap, sn->entry[i].name_off))) {
- fprintf(stream, "%*s%-*s `%s'\n", indent, "", fwidth,
- "Name:",
- s);
+
+ if (heap>0 && H5F_addr_defined(heap)) {
+ if (NULL == (heap_ptr = H5HL_protect(f, dxpl_id, heap)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to protect symbol name");
+
+ s = H5HL_offset_into(f, heap_ptr, sn->entry[i].name_off);
+
+ if (s)
+ fprintf(stream, "%*s%-*s `%s'\n", indent, "", fwidth, "Name:", s);
+
+ if (H5HL_unprotect(f, dxpl_id, heap_ptr, heap) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol name");
+ heap_ptr=NULL; s=NULL;
}
else
fprintf(stream, "%*s%-*s\n", indent, "", fwidth, "Warning: Invalid heap address given, name not displayed!");
diff --git a/src/H5HL.c b/src/H5HL.c
index 40350ce..3813efe 100644
--- a/src/H5HL.c
+++ b/src/H5HL.c
@@ -28,7 +28,11 @@
*
*-------------------------------------------------------------------------
*/
-#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+#define H5F_PACKAGE /* Suppress error about including H5Fpkg */
+
+/* Pablo information */
+/* (Put before include files to avoid problems with inline functions) */
+#define PABLO_MASK H5HL_mask
#include "H5private.h" /* Generic Functions */
#include "H5ACprivate.h" /* Metadata cache */
@@ -39,9 +43,6 @@
#include "H5MFprivate.h" /* File memory management */
#include "H5MMprivate.h" /* Memory management */
-/* Pablo information */
-#define PABLO_MASK H5HL_mask
-
/* Private macros */
#define H5HL_FREE_NULL 1 /*end of free list on disk */
#define H5HL_MIN_HEAP 256 /* Minimum size to reduce heap buffer to */
@@ -65,7 +66,7 @@ typedef struct H5HL_free_t {
struct H5HL_free_t *next; /*next entry in free list */
} H5HL_free_t;
-typedef struct H5HL_t {
+struct H5HL_t {
H5AC_info_t cache_info; /* Information for H5AC cache functions, _must_ be */
/* first field in structure */
haddr_t addr; /*address of data */
@@ -74,7 +75,7 @@ typedef struct H5HL_t {
size_t disk_resrv; /*data bytes "reserved" on disk */
uint8_t *chunk; /*the chunk, including header */
H5HL_free_t *freelist; /*the free list */
-} H5HL_t;
+};
/* PRIVATE PROTOTYPES */
#ifdef NOT_YET
@@ -83,7 +84,10 @@ static void *H5HL_read(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset, siz
static herr_t H5HL_write(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset, size_t size,
const void *buf);
#endif /* NOT_YET */
-static H5HL_free_t * H5HL_remove_free(H5HL_t *heap, H5HL_free_t *fl);
+
+static herr_t H5HL_serialize(H5F_t *f, H5HL_t *heap, uint8_t *buf);
+static H5HL_free_t *H5HL_remove_free(H5HL_t *heap, H5HL_free_t *fl);
+static herr_t H5HL_minimize_heap_space(H5F_t *f, hid_t dxpl_id, H5HL_t *heap);
/* Metadata cache callbacks */
static H5HL_t *H5HL_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *udata1,
@@ -275,7 +279,7 @@ H5HL_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED * udata1,
/* Allocate space in memory for the heap */
if (NULL==(heap = H5FL_CALLOC(H5HL_t)))
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-
+
/* heap data size */
H5F_DECODE_LENGTH(f, p, heap->disk_alloc);
heap->mem_alloc = heap->disk_alloc;
@@ -328,6 +332,219 @@ done:
/*-------------------------------------------------------------------------
+ * Function: H5HL_minimize_heap_space
+ *
+ * Purpose: Go through the heap's freelist and determine if we can
+ * eliminate the free blocks at the tail of the buffer.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Bill Wendling
+ * wendling@ncsa.uiuc.edu
+ * Sept. 16, 2003
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5HL_minimize_heap_space(H5F_t *f, hid_t dxpl_id, H5HL_t *heap)
+{
+ herr_t ret_value = SUCCEED;
+ size_t sizeof_hdr;
+
+ FUNC_ENTER_NOAPI(H5HL_minimize_heap_space, FAIL)
+
+ /* check args */
+ assert(f);
+ assert(heap);
+
+ sizeof_hdr = H5HL_SIZEOF_HDR(f); /* cache H5HL header size for file */
+
+ /*
+ * When the heap is being flushed to disk, release the file space reserved
+ * for it.
+ */
+ H5MF_free_reserved(f, (hsize_t)heap->disk_resrv);
+ heap->disk_resrv = 0;
+
+ /*
+ * Check to see if we can reduce the size of the heap in memory by
+ * eliminating free blocks at the tail of the buffer before flushing the
+ * buffer out.
+ */
+ if (heap->freelist) {
+ H5HL_free_t *tmp_fl;
+ H5HL_free_t *last_fl = NULL;
+
+ /* Search for a free block at the end of the buffer */
+ for (tmp_fl = heap->freelist; tmp_fl; tmp_fl = tmp_fl->next)
+ /* Check if the end of this free block is at the end of the buffer */
+ if (tmp_fl->offset + tmp_fl->size == heap->mem_alloc) {
+ last_fl = tmp_fl;
+ break;
+ }
+
+ /*
+ * Found free block at the end of the buffer, decide what to do
+ * about it
+ */
+ if (last_fl) {
+ size_t new_mem_size = heap->mem_alloc; /* New size of memory buffer */
+
+ /*
+ * If the last free block's size is more than half the memory
+ * buffer size (and the memory buffer is larger than the
+ * minimum size), reduce or eliminate it.
+ */
+ if (last_fl->size >= (heap->mem_alloc / 2) && heap->mem_alloc > H5HL_MIN_HEAP) {
+ /*
+ * Reduce size of buffer until it's too small or would
+ * eliminate the free block
+ */
+ while (new_mem_size > H5HL_MIN_HEAP &&
+ new_mem_size >= (last_fl->offset + H5HL_SIZEOF_FREE(f)))
+ new_mem_size /= 2;
+
+ /*
+ * Check if reducing the memory buffer size would
+ * eliminate the free list
+ */
+ if (new_mem_size < (last_fl->offset + H5HL_SIZEOF_FREE(f))) {
+ /* Check if this is the only block on the free list */
+ if (last_fl->prev == NULL && last_fl->next == NULL) {
+ /* Double the new memory size */
+ new_mem_size *= 2;
+
+ /* Truncate the free block */
+ last_fl->size = H5HL_ALIGN(new_mem_size - last_fl->offset);
+ new_mem_size = last_fl->offset + last_fl->size;
+ assert(last_fl->size >= H5HL_SIZEOF_FREE(f));
+ } else {
+ /*
+ * Set the size of the memory buffer to the start
+ * of the free list
+ */
+ new_mem_size = last_fl->offset;
+
+ /* Eliminate the free block from the list */
+ last_fl = H5HL_remove_free(heap, last_fl);
+ }
+ } else {
+ /* Truncate the free block */
+ last_fl->size = H5HL_ALIGN(new_mem_size - last_fl->offset);
+ new_mem_size = last_fl->offset + last_fl->size;
+ assert(last_fl->size >= H5HL_SIZEOF_FREE(f));
+ assert(last_fl->size == H5HL_ALIGN(last_fl->size));
+ }
+
+ /* Resize the memory buffer and reserved space in file */
+ if (new_mem_size != heap->mem_alloc) {
+
+ heap->mem_alloc = new_mem_size;
+ heap->chunk = H5FL_BLK_REALLOC(heap_chunk, heap->chunk, (sizeof_hdr + new_mem_size));
+
+ if (!heap->chunk)
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+ }
+ }
+ }
+ }
+
+ /*
+ * If the heap grew larger or smaller than disk storage then move the
+ * data segment of the heap to another contiguous block of disk
+ * storage.
+ */
+ if (heap->mem_alloc != heap->disk_alloc) {
+ haddr_t old_addr = heap->addr, new_addr;
+
+ /* Release old space on disk */
+ H5_CHECK_OVERFLOW(heap->disk_alloc, size_t, hsize_t);
+ H5MF_xfree(f, H5FD_MEM_LHEAP, dxpl_id, old_addr, (hsize_t)heap->disk_alloc);
+ H5E_clear(); /* don't really care if the free failed */
+
+ /* Allocate new space on disk */
+ H5_CHECK_OVERFLOW(heap->mem_alloc, size_t, hsize_t);
+
+ if (HADDR_UNDEF == (new_addr = H5MF_alloc(f, H5FD_MEM_LHEAP, dxpl_id, (hsize_t)heap->mem_alloc)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate file space for heap")
+
+ heap->addr = new_addr;
+
+ /* Set new size of block on disk */
+ heap->disk_alloc = heap->mem_alloc;
+ }
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5HL_serialize
+ *
+ * Purpose: Serialize the heap. This function will eliminate free
+ * blocks at the tail of the heap and also split the block
+ * if it needs to be split for the file. This is so that we
+ * can serialize it correctly.
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Bill Wendling
+ * wendling@ncsa.uiuc.edu
+ * Sept. 16, 2003
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5HL_serialize(H5F_t *f, H5HL_t *heap, uint8_t *buf)
+{
+ H5HL_free_t *fl;
+ uint8_t *p;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HL_serialize)
+
+ /* check args */
+ assert(buf);
+ assert(heap);
+
+ /* serialize the header */
+ p = buf;
+ fl = heap->freelist;
+ HDmemcpy(p, H5HL_MAGIC, H5HL_SIZEOF_MAGIC);
+ p += H5HL_SIZEOF_MAGIC;
+ *p++ = H5HL_VERSION;
+ *p++ = 0; /*reserved*/
+ *p++ = 0; /*reserved*/
+ *p++ = 0; /*reserved*/
+ H5F_ENCODE_LENGTH(f, p, heap->mem_alloc);
+ H5F_ENCODE_LENGTH(f, p, fl ? fl->offset : H5HL_FREE_NULL);
+ H5F_addr_encode(f, &p, heap->addr);
+
+ /* serialize the free list */
+ for (; fl; fl = fl->next) {
+ assert (fl->offset == H5HL_ALIGN (fl->offset));
+ p = heap->chunk + H5HL_SIZEOF_HDR(f) + fl->offset;
+
+ if (fl->next) {
+ H5F_ENCODE_LENGTH(f, p, fl->next->offset);
+ } else {
+ H5F_ENCODE_LENGTH(f, p, H5HL_FREE_NULL);
+ }
+
+ H5F_ENCODE_LENGTH(f, p, fl->size);
+ }
+
+ FUNC_LEAVE_NOAPI(ret_value)
+}
+
+
+/*-------------------------------------------------------------------------
* Function: H5HL_flush
*
* Purpose: Flushes a heap from memory to disk if it's dirty. Optionally
@@ -340,25 +557,24 @@ done:
* Jul 17 1997
*
* Modifications:
- * rky, 1998-08-28
- * Only p0 writes metadata to disk.
+ * rky, 1998-08-28
+ * Only p0 writes metadata to disk.
*
- * Robb Matzke, 1999-07-28
- * The ADDR argument is passed by value.
+ * Robb Matzke, 1999-07-28
+ * The ADDR argument is passed by value.
*
* Quincey Koziol, 2002-7-180
* Added dxpl parameter to allow more control over I/O from metadata
* cache.
+ *
+ * Bill Wendling, 2003-09-16
+ * Separated out the bit that serializes the heap.
*-------------------------------------------------------------------------
*/
static herr_t
H5HL_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5HL_t *heap)
{
- uint8_t *p;
- H5HL_free_t *fl;
- haddr_t hdr_end_addr;
- size_t sizeof_hdr; /* Cache H5HL header size for file */
- herr_t ret_value=SUCCEED; /* Return value */
+ herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5HL_flush, FAIL);
@@ -368,176 +584,45 @@ H5HL_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5HL_t *heap)
assert(heap);
if (heap->cache_info.dirty) {
- /* Cache this for later */
- sizeof_hdr= H5HL_SIZEOF_HDR(f);
+ haddr_t hdr_end_addr;
+ size_t sizeof_hdr = H5HL_SIZEOF_HDR(f); /* cache H5HL header size for file */
- /*
- * Since the file is being flushed to disk, release the file space reserved
- * for it.
- */
- H5MF_free_reserved(f, heap->disk_resrv);
- heap->disk_resrv = 0;
-
- /*
- * Check to see if we can reduce the size of the heap in memory by
- * eliminating free blocks at the tail of the buffer before flushing the
- * buffer out.
- */
- if(heap->freelist) {
- H5HL_free_t *tmp_fl=heap->freelist;
- H5HL_free_t *last_fl=NULL;
-
- /* Search for a free block at the end of the buffer */
- while(tmp_fl!=NULL) {
- /* Check if the end of this free block is at the end of the buffer */
- if(tmp_fl->offset + tmp_fl->size == heap->mem_alloc) {
- last_fl=tmp_fl;
- break;
- } /* end if */
- tmp_fl=tmp_fl->next;
- } /* end while */
-
- /* Found free block at the end of the buffer, decide what to do about it */
- if(last_fl) {
- size_t new_mem_size=heap->mem_alloc; /* New size of memory buffer */
-
- /*
- *If the last free block's size is more than half the memory
- * buffer size (and the memory buffer is larger than the minimum
- * size), reduce or eliminate it.
- */
- if(last_fl->size>=(heap->mem_alloc/2) && heap->mem_alloc>H5HL_MIN_HEAP) {
- /* Reduce size of buffer until it's too small or would eliminate the free block */
- while(new_mem_size>H5HL_MIN_HEAP &&
- new_mem_size>=(last_fl->offset+H5HL_SIZEOF_FREE(f)))
- new_mem_size /= 2;
-
- /* Check if reducing the memory buffer size would eliminate the free list */
- if(new_mem_size<(last_fl->offset+H5HL_SIZEOF_FREE(f))) {
- /* Check if this is the only block on the free list */
- if(last_fl->prev==NULL && last_fl->next==NULL) {
- /* Double the new memory size */
- new_mem_size *=2;
-
- /* Truncate the free block */
- last_fl->size=H5HL_ALIGN(new_mem_size-last_fl->offset);
- new_mem_size=last_fl->offset+last_fl->size;
- assert(last_fl->size>=H5HL_SIZEOF_FREE(f));
- } /* end if */
- else {
- /* Set the size of the memory buffer to the start of the free list */
- new_mem_size=last_fl->offset;
-
- /* Eliminate the free block from the list */
- last_fl = H5HL_remove_free(heap, last_fl);
- } /* end else */
- } /* end if */
- else {
- /* Truncate the free block */
- last_fl->size=H5HL_ALIGN(new_mem_size-last_fl->offset);
- new_mem_size=last_fl->offset+last_fl->size;
- assert(last_fl->size>=H5HL_SIZEOF_FREE(f));
- assert(last_fl->size==H5HL_ALIGN(last_fl->size));
- } /* end else */
-
- /* Resize the memory buffer */
- if(new_mem_size!=heap->mem_alloc) {
- heap->mem_alloc=new_mem_size;
- heap->chunk = H5FL_BLK_REALLOC(heap_chunk,heap->chunk,
- (sizeof_hdr + new_mem_size));
- if (NULL==heap->chunk)
- HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
- } /* end if */
- } /* end if */
- } /* end if */
- } /* end if */
-
- /*
- * If the heap grew larger or smaller than disk storage then move the
- * data segment of the heap to another contiguous block of
- * disk storage.
- */
- if (heap->mem_alloc != heap->disk_alloc) {
- haddr_t old_addr = heap->addr, new_addr;
-
- /* Release old space on disk */
- H5_CHECK_OVERFLOW(heap->disk_alloc,size_t,hsize_t);
- H5MF_xfree(f, H5FD_MEM_LHEAP, dxpl_id, old_addr, (hsize_t)heap->disk_alloc);
- H5E_clear(); /*don't really care if the free failed */
-
- /* Allocate new space on disk */
- H5_CHECK_OVERFLOW(heap->mem_alloc,size_t,hsize_t);
- if (HADDR_UNDEF==(new_addr=H5MF_alloc(f, H5FD_MEM_LHEAP, dxpl_id,
- (hsize_t)heap->mem_alloc)))
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate file space for heap");
- heap->addr = new_addr;
-
- /* Set new size of block on disk */
- heap->disk_alloc = heap->mem_alloc;
- }
+ /* Minimize the heap space size if possible */
+ if (H5HL_minimize_heap_space(f, dxpl_id, heap) < 0)
+ HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to minimize local heap space")
- /*
- * Write the header.
- */
- p = heap->chunk;
- fl=heap->freelist;
- HDmemcpy(p, H5HL_MAGIC, H5HL_SIZEOF_MAGIC);
- p += H5HL_SIZEOF_MAGIC;
- *p++ = H5HL_VERSION;
- *p++ = 0; /*reserved*/
- *p++ = 0; /*reserved*/
- *p++ = 0; /*reserved*/
- H5F_ENCODE_LENGTH(f, p, heap->mem_alloc);
- H5F_ENCODE_LENGTH(f, p, fl ? fl->offset : H5HL_FREE_NULL);
- H5F_addr_encode(f, &p, heap->addr);
-
- /*
- * Write the free list.
- */
- while (fl) {
- assert (fl->offset == H5HL_ALIGN (fl->offset));
- p = heap->chunk + sizeof_hdr + fl->offset;
- if (fl->next) {
- H5F_ENCODE_LENGTH(f, p, fl->next->offset);
- } else {
- H5F_ENCODE_LENGTH(f, p, H5HL_FREE_NULL);
- }
- H5F_ENCODE_LENGTH(f, p, fl->size);
- fl = fl->next;
- }
+ /* Write the header */
+ if (H5HL_serialize(f, heap, heap->chunk) < 0)
+ HGOTO_ERROR(H5E_BTREE, H5E_WRITEERROR, FAIL, "unable to serialize local heap")
- /*
- * Copy buffer to disk.
- */
+ /* Copy buffer to disk */
hdr_end_addr = addr + (hsize_t)sizeof_hdr;
+
if (H5F_addr_eq(heap->addr, hdr_end_addr)) {
/* The header and data are contiguous */
- if (H5F_block_write(f, H5FD_MEM_LHEAP, addr,
- (sizeof_hdr+heap->disk_alloc),
+ if (H5F_block_write(f, H5FD_MEM_LHEAP, addr, (sizeof_hdr + heap->disk_alloc),
dxpl_id, heap->chunk) < 0)
- HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "unable to write heap header and data to file");
+ HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "unable to write heap header and data to file")
} else {
- if (H5F_block_write(f, H5FD_MEM_LHEAP, addr, sizeof_hdr,
- dxpl_id, heap->chunk)<0)
- HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "unable to write heap header to file");
+ if (H5F_block_write(f, H5FD_MEM_LHEAP, addr, sizeof_hdr, dxpl_id, heap->chunk) < 0)
+ HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "unable to write heap header to file")
+
if (H5F_block_write(f, H5FD_MEM_LHEAP, heap->addr, heap->disk_alloc,
dxpl_id, heap->chunk + sizeof_hdr) < 0)
- HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "unable to write heap data to file");
+ HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "unable to write heap data to file")
}
- heap->cache_info.dirty = 0;
+ heap->cache_info.dirty = FALSE;
}
- /*
- * Should we destroy the memory version?
- */
+ /* Should we destroy the memory version? */
if (destroy) {
- if(H5HL_dest(f,heap)<0)
- HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy local heap collection");
+ if (H5HL_dest(f,heap) < 0)
+ HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy local heap collection")
}
done:
- FUNC_LEAVE_NOAPI(ret_value);
+ FUNC_LEAVE_NOAPI(ret_value)
}
@@ -567,7 +652,7 @@ H5HL_dest(H5F_t UNUSED *f, H5HL_t *heap)
assert(heap);
/* Verify that node is clean */
- assert (heap->cache_info.dirty==0);
+ assert (heap->cache_info.dirty==FALSE);
if(heap->chunk)
heap->chunk = H5FL_BLK_FREE(heap_chunk,heap->chunk);
@@ -606,7 +691,7 @@ H5HL_clear(H5HL_t *heap)
assert(heap);
/* Mark heap as clean */
- heap->cache_info.dirty = 0;
+ heap->cache_info.dirty = FALSE;
FUNC_LEAVE_NOAPI(SUCCEED);
} /* end H5HL_clear() */
@@ -652,8 +737,9 @@ H5HL_read(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset, size_t size, voi
assert(f);
assert (H5F_addr_defined(addr));
- if (NULL == (heap = H5AC_find(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
+ if (NULL == (heap = H5AC_protect(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "unable to load heap");
+
assert(offset < heap->mem_alloc);
assert(offset + size <= heap->mem_alloc);
@@ -665,60 +751,128 @@ H5HL_read(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset, size_t size, voi
ret_value=buf;
done:
+ if (heap && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP, addr, heap, FALSE) != SUCCEED)
+ HDONE_ERROR(H5E_HEAP, H5E_PROTECT, NULL, "unable to release object header");
+
FUNC_LEAVE_NOAPI(ret_value);
}
#endif /* NOT_YET */
/*-------------------------------------------------------------------------
- * Function: H5HL_peek
+ * Function: H5HL_protect
+ *
+ * Purpose: This function is a wrapper for the H5AC_protect call. The
+ * old H5HL_peek call (which this once was) wasn't "safe"
+ * for FPHDF5. (It'd get a read lock on an object but once
+ * it got that object, it'd release it keeping the old
+ * pointer value, which is no longer valid. This won't work
+ * since the pointer into some metdata block can become
+ * invalid.)
+ *
+ * N.B.: This function is always called in conjunction with
+ * the H5HL_offset_into function. The return from that
+ * function is the proper pointer to the heap's object. This
+ * is done so that the return from this function can be sent
+ * to H5HL_unprotect.
+ *
+ * Return: Success: Ptr to the object. The pointer points to a
+ * chunk of memory large enough to hold the
+ * object from the specified offset (usually the
+ * beginning of the object) to the end of the
+ * object. Do not attempt to read past the end
+ * of the object.
+ * Failure: NULL
+ *
+ * Programmer: Bill Wendling
+ * wendling@ncsa.uiuc.edu
+ * Sept. 17, 2003
*
- * Purpose: This function is a more efficient version of H5HL_read.
- * Instead of copying a heap object into a caller-supplied
- * buffer, this function returns a pointer directly into the
- * cache where the heap is being held. Thus, the return pointer
- * is valid only until the next call to the cache.
+ * Modifications:
*
- * The address of the heap is ADDR in file F. OFFSET is the
- * byte offset of the object from the beginning of the heap and
- * may include an offset into the interior of the object.
+ *-------------------------------------------------------------------------
+ */
+const H5HL_t *
+H5HL_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr)
+{
+ H5HL_t *ret_value = NULL;
+
+ FUNC_ENTER_NOAPI(H5HL_protect, NULL);
+
+ /* check arguments */
+ assert(f);
+ assert(H5F_addr_defined(addr));
+
+ if (NULL == (ret_value = H5AC_protect(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
+ HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "unable to load heap");
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5HL_offset_into
*
- * Return: Success: Ptr to the object. The pointer points to
- * a chunk of memory large enough to hold the
- * object from the specified offset (usually
- * the beginning of the object) to the end
- * of the object. Do not attempt to read past
- * the end of the object.
+ * Purpose: Called directly after the call to H5HL_protect so that
+ * a pointer to the object in the heap can be got.
*
- * Failure: NULL
+ * Return: Success: Valid pointer.
+ * Failure: NULL
*
- * Programmer: Robb Matzke
- * matzke@llnl.gov
- * Jul 16 1997
+ * Programmer: Bill Wendling
+ * wendling@ncsa.uiuc.edu
+ * Sept. 17, 2003
*
* Modifications:
- * Robb Matzke, 1999-07-28
- * The ADDR argument is passed by value.
+ *
*-------------------------------------------------------------------------
*/
-const void *
-H5HL_peek(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset)
+void *
+H5HL_offset_into(H5F_t *f, const H5HL_t *heap, size_t offset)
{
- H5HL_t *heap;
- const void *ret_value;
+ /*
+ * We need to have called some other function before this to get a
+ * valid heap pointer. So, this can remain "FUNC_ENTER_NOAPI_NOINIT"
+ */
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HL_offset_into)
+ assert(f);
+ assert(heap);
+ assert(offset < heap->mem_alloc);
+ FUNC_LEAVE_NOAPI(heap->chunk + H5HL_SIZEOF_HDR(f) + offset)
+}
- FUNC_ENTER_NOAPI(H5HL_peek, NULL);
+
+/*-------------------------------------------------------------------------
+ * Function: H5HL_unprotect
+ *
+ * Purpose: Unprotect the data retrieved by the H5HL_protect call.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Bill Wendling
+ * wendling@ncsa.uiuc.edu
+ * Sept. 17, 2003
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5HL_unprotect(H5F_t *f, hid_t dxpl_id, const H5HL_t *heap, haddr_t addr)
+{
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_NOAPI(H5HL_unprotect, FAIL);
/* check arguments */
assert(f);
+ assert(heap);
assert(H5F_addr_defined(addr));
- if (NULL == (heap = H5AC_find(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
- HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "unable to load heap");
- assert(offset < heap->mem_alloc);
-
- /* Set return value */
- ret_value = heap->chunk + H5HL_SIZEOF_HDR(f) + offset;
+ if (H5AC_unprotect(f, dxpl_id, H5AC_LHEAP, addr, (void *)heap, FALSE) != SUCCEED)
+ HGOTO_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release object header");
done:
FUNC_LEAVE_NOAPI(ret_value);
@@ -781,7 +935,7 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t buf_size, const void *
size_t offset = 0;
size_t need_size, old_size, need_more;
hbool_t found;
- size_t disk_resrv; /* Amount of additional space to reserve in file */
+ size_t disk_resrv; /* Amount of additional space to reserve in file */
size_t sizeof_hdr; /* Cache H5HL header size for file */
size_t ret_value; /* Return value */
@@ -792,12 +946,14 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t buf_size, const void *
assert(H5F_addr_defined(addr));
assert(buf_size > 0);
assert(buf);
+
if (0==(f->intent & H5F_ACC_RDWR))
HGOTO_ERROR (H5E_HEAP, H5E_WRITEERROR, (size_t)(-1), "no write intent on file");
- if (NULL == (heap = H5AC_find(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
- HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, (size_t)(-1), "unable to load heap");
- heap->cache_info.dirty += 1;
+ if (NULL == (heap = H5AC_protect(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
+ HGOTO_ERROR(H5E_HEAP, H5E_PROTECT, (size_t)(-1), "unable to load heap");
+
+ heap->cache_info.dirty=TRUE;
/* Cache this for later */
sizeof_hdr= H5HL_SIZEOF_HDR(f);
@@ -845,6 +1001,19 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t buf_size, const void *
if (found==FALSE) {
need_more = MAX3(need_size, heap->mem_alloc, H5HL_SIZEOF_FREE(f));
+ /* Reserve space in the file to hold the increased heap size
+ */
+ if( heap->disk_resrv == heap->mem_alloc)
+ disk_resrv = need_more;
+ else
+ disk_resrv = heap->mem_alloc + need_more - heap->disk_resrv;
+
+ if( H5MF_reserve(f, (hsize_t)disk_resrv) < 0 )
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, (size_t)(-1), "unable to reserve space in file");
+
+ /* Update heap's record of how much space it has reserved */
+ heap->disk_resrv += disk_resrv;
+
if (max_fl && max_fl->offset + max_fl->size == heap->mem_alloc) {
/*
* Increase the size of the maximum free block.
@@ -890,18 +1059,6 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t buf_size, const void *
}
}
- /* Reserve space in file to hold the increased heap size */
- if( heap->disk_resrv == heap->mem_alloc)
- disk_resrv = need_more;
- else
- disk_resrv = heap->mem_alloc + need_more - heap->disk_resrv;
-
- if( H5MF_reserve(f, disk_resrv) < 0)
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, (size_t) (-1), "unable to reserve space for heap");
-
- /* Update heap's record of how much space it has reserved */
- heap->disk_resrv += disk_resrv;
-
#ifdef H5HL_DEBUG
if (H5DEBUG(HL)) {
fprintf(H5DEBUG(HL),
@@ -929,6 +1086,9 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t buf_size, const void *
ret_value=offset;
done:
+ if (heap && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP, addr, heap, FALSE) != SUCCEED)
+ HDONE_ERROR(H5E_HEAP, H5E_PROTECT, (size_t)(-1), "unable to release object header");
+
FUNC_LEAVE_NOAPI(ret_value);
}
@@ -969,18 +1129,23 @@ H5HL_write(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset, size_t size, co
assert(H5F_addr_defined(addr));
assert(buf);
assert (offset==H5HL_ALIGN (offset));
+
if (0==(f->intent & H5F_ACC_RDWR))
HGOTO_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL, "no write intent on file");
- if (NULL == (heap = H5AC_find(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
- HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to load heap");
+ if (NULL == (heap = H5AC_protect(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
+ HGOTO_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to load heap");
+
assert(offset < heap->mem_alloc);
assert(offset + size <= heap->mem_alloc);
- heap->cache_info.dirty += 1;
+ heap->cache_info.dirty=TRUE;
HDmemcpy(heap->chunk + H5HL_SIZEOF_HDR(f) + offset, buf, size);
done:
+ if (heap && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP, addr, heap, FALSE) != SUCCEED && ret_value != FAIL)
+ HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release object header");
+
FUNC_LEAVE_NOAPI(ret_value);
}
#endif /* NOT_YET */
@@ -1027,17 +1192,20 @@ H5HL_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset, size_t size)
assert(H5F_addr_defined(addr));
assert(size > 0);
assert (offset==H5HL_ALIGN (offset));
+
if (0==(f->intent & H5F_ACC_RDWR))
HGOTO_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL, "no write intent on file");
size = H5HL_ALIGN (size);
- if (NULL == (heap = H5AC_find(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
- HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to load heap");
+
+ if (NULL == (heap = H5AC_protect(f, dxpl_id, H5AC_LHEAP, addr, NULL, NULL)))
+ HGOTO_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to load heap");
+
assert(offset < heap->mem_alloc);
assert(offset + size <= heap->mem_alloc);
- fl = heap->freelist;
- heap->cache_info.dirty += 1;
+ fl = heap->freelist;
+ heap->cache_info.dirty=TRUE;
/*
* Check if this chunk can be prepended or appended to an already
@@ -1112,6 +1280,9 @@ H5HL_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset, size_t size)
heap->freelist = fl;
done:
+ if (heap && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP, addr, heap, FALSE) != SUCCEED)
+ HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release object header");
+
FUNC_LEAVE_NOAPI(ret_value);
}
diff --git a/src/H5HLprivate.h b/src/H5HLprivate.h
index aa2a2d4..711f8b5 100644
--- a/src/H5HLprivate.h
+++ b/src/H5HLprivate.h
@@ -51,11 +51,16 @@
H5HL_ALIGN(H5F_SIZEOF_SIZE (F) + /*ptr to next free block */ \
H5F_SIZEOF_SIZE (F)) /*size of this free block */
+/* Typedef for local heap in memory (defined in H5HL.c) */
+typedef struct H5HL_t H5HL_t;
+
/*
* Library prototypes...
*/
H5_DLL herr_t H5HL_create(H5F_t *f, hid_t dxpl_id, size_t size_hint, haddr_t *addr/*out*/);
-H5_DLL const void *H5HL_peek(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset);
+H5_DLL const H5HL_t *H5HL_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr);
+H5_DLL void *H5HL_offset_into(H5F_t *f, const H5HL_t *heap, size_t offset);
+H5_DLL herr_t H5HL_unprotect(H5F_t *f, hid_t dxpl_id, const H5HL_t *heap, haddr_t addr);
H5_DLL size_t H5HL_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t size,
const void *buf);
H5_DLL herr_t H5HL_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t offset, size_t size);
diff --git a/src/H5MF.c b/src/H5MF.c
index 97b2965..9da1a0f 100644
--- a/src/H5MF.c
+++ b/src/H5MF.c
@@ -32,14 +32,16 @@
*/
#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+/* Pablo information */
+/* (Put before include files to avoid problems with inline functions) */
+#define PABLO_MASK H5MF_mask
+
#include "H5private.h"
#include "H5Eprivate.h"
#include "H5Fpkg.h"
#include "H5FDprivate.h"
#include "H5MFprivate.h"
-#define PABLO_MASK H5MF_mask
-
/* Is the interface initialized? */
static int interface_initialize_g = 0;
#define INTERFACE_INIT NULL
@@ -80,13 +82,14 @@ H5MF_alloc(H5F_t *f, H5FD_mem_t type, hid_t dxpl_id, hsize_t size)
/* Fail if we don't have write access */
if (0==(f->intent & H5F_ACC_RDWR))
HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, HADDR_UNDEF, "file is read-only");
+
/* Check that the file can address the new space */
- if( H5MF_alloc_overflow(f, size) != 0 )
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "not enough address space in file");
+ if( H5MF_alloc_overflow(f, size) )
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, HADDR_UNDEF, "not enough address space in file");
/* Allocate space from the virtual file layer */
if (HADDR_UNDEF==(ret_value=H5FD_alloc(f->shared->lf, type, dxpl_id, size)))
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, HADDR_UNDEF, "file allocation failed");
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, HADDR_UNDEF, "file allocation failed");
/* Convert absolute file address to relative file address */
assert(ret_value>=f->shared->base_addr);
@@ -197,6 +200,11 @@ H5MF_realloc(H5F_t *f, H5FD_mem_t type, hid_t dxpl_id, haddr_t old_addr, hsize_t
/* Convert old relative address to absolute address */
old_addr += f->shared->base_addr;
+ /* Check that the file can address the new space. */
+ /* In the worst case, this means adding new_size bytes to the end of the file. */
+ if( H5MF_alloc_overflow(f, new_size) )
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, HADDR_UNDEF, "not enough address space in file");
+
/* Reallocate memory from the virtual file layer */
ret_value = H5FD_realloc(f->shared->lf, type, dxpl_id, old_addr, old_size,
new_size);
@@ -214,104 +222,119 @@ done:
}
/*-------------------------------------------------------------------------
- * Function: H5MF_reserve
+ * Function: H5MF_reserve
*
- * Purpose: Sets aside file space that has not yet been allocated, but will
- * be (or might be in the worst case). This number is used to
- * ensure that there is room in the file when it is flushed to disk.
+ * Purpose: Sets aside file space that has not yet been allocated, but will
+ * be (or might be in the worst case). This number is used to
+ * ensure that there is room in the file when it is flushed to disk.
*
- * Nothing changes (and no error is generated) if the file is opened
- * as read-only.
+ * Nothing changes (and no error is generated) if the file is opened
+ * as read-only.
*
- * Return: Success: 0
+ * Return: Success: 0
*
- * Failure: negative
+ * Failure: negative
*
- * Programmer: James Laird
- * Nat Furrer
+ * Programmer: James Laird
+ * Nat Furrer
* Thursday, May 27, 2004
*
* Modifications:
*-------------------------------------------------------------------------
*/
-herr_t H5MF_reserve(H5F_t *f, hsize_t size)
+herr_t
+H5MF_reserve(H5F_t *f, hsize_t size)
{
- herr_t ret_value = SUCCEED;
+ herr_t ret_value = SUCCEED;
+
FUNC_ENTER_NOAPI(H5MF_reserve, FAIL);
- /* Check arguments */
- assert(f);
+ /* Check arguments */
+ assert(f);
- /* Check that there is room in the file to reserve this space */
- if( H5MF_alloc_overflow( f, size ) != 0)
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "not enough address space in file");
+ /* Check that there is room in the file to reserve this space */
+ if( H5MF_alloc_overflow( f, size ) )
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "not enough address space in file");
- f->shared->lf->reserved_alloc += size;
+ f->shared->lf->reserved_alloc += size;
done:
- FUNC_LEAVE_NOAPI(ret_value);
+ FUNC_LEAVE_NOAPI(ret_value);
}
/*-------------------------------------------------------------------------
- * Function: H5MF_free_reserved
+ * Function: H5MF_free_reserved
*
- * Purpose: Releases the file space set aside by H5MF_reserve. This should
- * be called immediately before allocating the file space for which
- * the space was reserved.
+ * Purpose: Releases the file space set aside by H5MF_reserve. This should
+ * be called immediately before allocating the file space for which
+ * the space was reserved.
*
- * Return: None
+ * Return: None
*
- * Programmer: James Laird
- * Nat Furrer
+ * Programmer: James Laird
+ * Nat Furrer
* Thursday, May 27, 2004
*
* Modifications:
*-------------------------------------------------------------------------
*/
-void H5MF_free_reserved(H5F_t *f, hsize_t size)
+herr_t
+H5MF_free_reserved(H5F_t *f, hsize_t size)
{
- /* Check arguments */
- assert(f);
+ herr_t ret_value = SUCCEED;
- /* If this assert breaks, it means that HDF5 is trying to free file space
- * that was never reserved.
- */
- assert(size <= f->shared->lf->reserved_alloc);
+ FUNC_ENTER_NOAPI(H5MF_free_reserved,FAIL)
+
+ /* Check arguments */
+ assert(f);
+
+ /* If this assert breaks, it means that HDF5 is trying to free file space
+ * that was never reserved.
+ */
+ assert(size <= f->shared->lf->reserved_alloc);
- f->shared->lf->reserved_alloc -= size;
+ f->shared->lf->reserved_alloc -= size;
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
}
/*-------------------------------------------------------------------------
- * Function: H5MF_alloc_overflow
+ * Function: H5MF_alloc_overflow
*
- * Purpose: Checks if an allocation of file space would cause an overflow.
+ * Purpose: Checks if an allocation of file space would cause an overflow.
* F is the file whose space is being allocated, SIZE is the amount
* of space needed.
*
- * Return: 0 if no overflow would result
+ * Return: 0 if no overflow would result
* 1 if overflow would result (the allocation should not be allowed)
*
- * Programmer: James Laird
- * Nat Furrer
+ * Programmer: James Laird
+ * Nat Furrer
* Tuesday, June 1, 2004
*
* Modifications:
*-------------------------------------------------------------------------
*/
-int H5MF_alloc_overflow(H5F_t *f, hsize_t size)
+hbool_t
+H5MF_alloc_overflow(H5F_t *f, hsize_t size)
{
- hsize_t space_needed; /* Accumulator variable */
- size_t c;
+ hsize_t space_needed; /* Accumulator variable */
+ size_t c; /* Local index variable */
+ hbool_t ret_value; /* Return value */
+
+ FUNC_ENTER_NOAPI(H5MF_alloc_overflow,FALSE)
/* Start with the current end of the file's address. */
- space_needed = f->shared->lf->cls->get_eoa(f->shared->lf);
+ space_needed = (hsize_t)H5F_get_eoa(f);
+ HDassert(H5F_addr_defined(space_needed));
/* Subtract the file's base address to get the actual amount of
* space being used:
* (end of allocated space - beginning of allocated space)
*/
- assert(f->shared->base_addr < space_needed);
- space_needed -= f->shared->base_addr;
+ HDassert(H5F_BASE_ADDR(f) < space_needed);
+ space_needed -= (hsize_t)H5F_BASE_ADDR(f);
/* Add the amount of space requested for this allocation */
space_needed += size;
@@ -334,9 +357,12 @@ int H5MF_alloc_overflow(H5F_t *f, hsize_t size)
space_needed = space_needed >> 16;
if(space_needed != 0)
- return 1;
+ ret_value=TRUE;
else
- return 0;
+ ret_value=FALSE;
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
}
@@ -365,11 +391,11 @@ htri_t
H5MF_can_extend(H5F_t *f, H5FD_mem_t type, haddr_t addr, hsize_t size, hsize_t extra_requested)
{
htri_t ret_value; /* Return value */
-
+
FUNC_ENTER_NOAPI(H5MF_can_extend, FAIL);
/* Convert old relative address to absolute address */
- addr += f->shared->base_addr;
+ addr += H5F_BASE_ADDR(f);
/* Pass the request down to the virtual file layer */
if((ret_value=H5FD_can_extend(f->shared->lf, type, addr, size, extra_requested))<0)
@@ -404,16 +430,16 @@ htri_t
H5MF_extend(H5F_t *f, H5FD_mem_t type, haddr_t addr, hsize_t size, hsize_t extra_requested)
{
htri_t ret_value; /* Return value */
-
- FUNC_ENTER_NOAPI(H5MF_extend, FAIL);
- /* Convert old relative address to absolute address */
- addr += f->shared->base_addr;
+ FUNC_ENTER_NOAPI(H5MF_extend, FAIL);
/* Make sure there is enough addressable space to satisfy the request */
if ( H5MF_alloc_overflow(f, extra_requested) )
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate new file memory: out of address space");
+ /* Convert old relative address to absolute address */
+ addr += H5F_BASE_ADDR(f);
+
/* Pass the request down to the virtual file layer */
if((ret_value=H5FD_extend(f->shared->lf, type, addr, size, extra_requested))<0)
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate new file memory");
@@ -421,4 +447,3 @@ H5MF_extend(H5F_t *f, H5FD_mem_t type, haddr_t addr, hsize_t size, hsize_t extra
done:
FUNC_LEAVE_NOAPI(ret_value);
} /* end H5MF_extend() */
-
diff --git a/src/H5MFprivate.h b/src/H5MFprivate.h
index 2a129ea..ee35c2a 100644
--- a/src/H5MFprivate.h
+++ b/src/H5MFprivate.h
@@ -49,8 +49,8 @@ H5_DLL herr_t H5MF_xfree(H5F_t *f, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr,
H5_DLL haddr_t H5MF_realloc(H5F_t *f, H5FD_mem_t type, hid_t dxpl_id, haddr_t old_addr,
hsize_t old_size, hsize_t new_size);
H5_DLL herr_t H5MF_reserve(H5F_t *f, hsize_t size);
-H5_DLL void H5MF_free_reserved(H5F_t *f, hsize_t size);
-H5_DLL int H5MF_alloc_overflow(H5F_t *f, hsize_t size);
+H5_DLL herr_t H5MF_free_reserved(H5F_t *f, hsize_t size);
+H5_DLL hbool_t H5MF_alloc_overflow(H5F_t *f, hsize_t size);
H5_DLL htri_t H5MF_can_extend(H5F_t *f, H5FD_mem_t type, haddr_t addr,
hsize_t size, hsize_t extra_requested);
H5_DLL htri_t H5MF_extend(H5F_t *f, H5FD_mem_t type, haddr_t addr, hsize_t size,
diff --git a/src/H5O.c b/src/H5O.c
index f318b92..a3b1618 100644
--- a/src/H5O.c
+++ b/src/H5O.c
@@ -716,11 +716,10 @@ H5O_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5O_t *oh)
assert(!H5F_addr_defined(oh->chunk[cont->chunkno].addr));
cont->size = oh->chunk[cont->chunkno].size;
- /* Free the space we'd previously reserved to hold this chunk */
- H5MF_free_reserved(f, cont->size);
+ /* Free the space we'd reserved in the file to hold this chunk */
+ H5MF_free_reserved(f, (hsize_t)cont->size);
- if (HADDR_UNDEF==(cont->addr=H5MF_alloc(f,
- H5FD_MEM_OHDR, dxpl_id, (hsize_t)cont->size)))
+ if (HADDR_UNDEF==(cont->addr=H5MF_alloc(f, H5FD_MEM_OHDR, dxpl_id, (hsize_t)cont->size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate space for object header data");
oh->chunk[cont->chunkno].addr = cont->addr;
}
@@ -822,7 +821,7 @@ H5O_dest(H5F_t UNUSED *f, H5O_t *oh)
assert(oh);
/* Verify that node is clean */
- assert (oh->cache_info.dirty==0);
+ assert (oh->cache_info.dirty==FALSE);
/* destroy chunks */
for (i = 0; i < oh->nchunks; i++) {
@@ -914,7 +913,7 @@ H5O_clear(H5O_t *oh)
*-------------------------------------------------------------------------
*/
herr_t
-H5O_reset(hid_t type_id, void *native)
+H5O_reset(unsigned type_id, void *native)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
herr_t ret_value; /* Return value */
@@ -922,7 +921,7 @@ H5O_reset(hid_t type_id, void *native)
FUNC_ENTER_NOAPI(H5O_reset,FAIL);
/* check args */
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert(type);
@@ -994,7 +993,7 @@ done:
*-------------------------------------------------------------------------
*/
void *
-H5O_free (hid_t type_id, void *mesg)
+H5O_free (unsigned type_id, void *mesg)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
void * ret_value; /* Return value */
@@ -1002,7 +1001,7 @@ H5O_free (hid_t type_id, void *mesg)
FUNC_ENTER_NOAPI(H5O_free, NULL);
/* check args */
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert(type);
@@ -1075,7 +1074,7 @@ H5O_free_real(const H5O_class_t *type, void *mesg)
*-------------------------------------------------------------------------
*/
void *
-H5O_copy (hid_t type_id, const void *mesg, void *dst)
+H5O_copy (unsigned type_id, const void *mesg, void *dst)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
void *ret_value; /* Return value */
@@ -1083,7 +1082,7 @@ H5O_copy (hid_t type_id, const void *mesg, void *dst)
FUNC_ENTER_NOAPI(H5O_copy, NULL);
/* check args */
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert(type);
@@ -1251,7 +1250,7 @@ done:
*-------------------------------------------------------------------------
*/
int
-H5O_count (H5G_entry_t *ent, hid_t type_id, hid_t dxpl_id)
+H5O_count (H5G_entry_t *ent, unsigned type_id, hid_t dxpl_id)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
int ret_value; /* Return value */
@@ -1262,7 +1261,7 @@ H5O_count (H5G_entry_t *ent, hid_t type_id, hid_t dxpl_id)
assert (ent);
assert (ent->file);
assert (H5F_addr_defined(ent->header));
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert (type);
@@ -1353,7 +1352,7 @@ done:
*-------------------------------------------------------------------------
*/
htri_t
-H5O_exists(H5G_entry_t *ent, hid_t type_id, int sequence, hid_t dxpl_id)
+H5O_exists(H5G_entry_t *ent, unsigned type_id, int sequence, hid_t dxpl_id)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
htri_t ret_value; /* Return value */
@@ -1362,7 +1361,7 @@ H5O_exists(H5G_entry_t *ent, hid_t type_id, int sequence, hid_t dxpl_id)
assert(ent);
assert(ent->file);
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert(type);
assert(sequence>=0);
@@ -1463,7 +1462,7 @@ done:
*-------------------------------------------------------------------------
*/
void *
-H5O_read(H5G_entry_t *ent, hid_t type_id, int sequence, void *mesg, hid_t dxpl_id)
+H5O_read(H5G_entry_t *ent, unsigned type_id, int sequence, void *mesg, hid_t dxpl_id)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
void *ret_value; /* Return value */
@@ -1474,7 +1473,7 @@ H5O_read(H5G_entry_t *ent, hid_t type_id, int sequence, void *mesg, hid_t dxpl_i
assert(ent);
assert(ent->file);
assert(H5F_addr_defined(ent->header));
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert(type);
assert(sequence >= 0);
@@ -1708,7 +1707,7 @@ done:
*-------------------------------------------------------------------------
*/
int
-H5O_modify(H5G_entry_t *ent, hid_t type_id, int overwrite,
+H5O_modify(H5G_entry_t *ent, unsigned type_id, int overwrite,
unsigned flags, unsigned update_time, const void *mesg, hid_t dxpl_id)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
@@ -1720,7 +1719,7 @@ H5O_modify(H5G_entry_t *ent, hid_t type_id, int overwrite,
assert(ent);
assert(ent->file);
assert(H5F_addr_defined(ent->header));
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert(type);
assert(mesg);
@@ -1961,7 +1960,7 @@ done:
*-------------------------------------------------------------------------
*/
int
-H5O_append(H5F_t *f, hid_t dxpl_id, H5O_t *oh, hid_t type_id, unsigned flags,
+H5O_append(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned type_id, unsigned flags,
const void *mesg)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
@@ -1972,7 +1971,7 @@ H5O_append(H5F_t *f, hid_t dxpl_id, H5O_t *oh, hid_t type_id, unsigned flags,
/* check args */
assert(f);
assert(oh);
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert(type);
assert(0==(flags & ~H5O_FLAG_BITS));
@@ -2413,7 +2412,7 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5O_remove(H5G_entry_t *ent, hid_t type_id, int sequence, hid_t dxpl_id)
+H5O_remove(H5G_entry_t *ent, unsigned type_id, int sequence, hid_t dxpl_id)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
herr_t ret_value; /* Return value */
@@ -2424,7 +2423,7 @@ H5O_remove(H5G_entry_t *ent, hid_t type_id, int sequence, hid_t dxpl_id)
assert(ent);
assert(ent->file);
assert(H5F_addr_defined(ent->header));
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert(type);
@@ -2540,9 +2539,9 @@ done:
* that message will be extended with the chunk. Otherwise a
* new null message is created.
*
- * F is the file into which the new chunk will be written. It is
- * included to ensure that there is enough space to extend this
- * chunk.
+ * F is the file in which the chunk will be written. It is
+ * included to ensure that there is enough space to extend
+ * this chunk.
*
* Return: Success: Message index for null message which
* is large enough to hold SIZE bytes.
@@ -2585,15 +2584,15 @@ H5O_alloc_extend_chunk(H5F_t *f, H5O_t *oh, unsigned chunkno, size_t size)
for (idx=0; idx<oh->nmesgs; idx++) {
if (oh->mesg[idx].chunkno==chunkno) {
if (H5O_NULL_ID == oh->mesg[idx].type->id &&
- (oh->mesg[idx].raw + oh->mesg[idx].raw_size ==
- oh->chunk[chunkno].image + oh->chunk[chunkno].size)) {
+ (oh->mesg[idx].raw + oh->mesg[idx].raw_size ==
+ oh->chunk[chunkno].image + oh->chunk[chunkno].size)) {
delta = MAX (H5O_MIN_SIZE, aligned_size - oh->mesg[idx].raw_size);
assert (delta=H5O_ALIGN (delta));
/* Reserve space in the file to hold the increased chunk size */
- if( H5MF_reserve(f, delta) < 0 )
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "unable to reserve space for chunk");
+ if( H5MF_reserve(f, (hsize_t)delta) < 0 )
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "unable to reserve space in file");
oh->mesg[idx].dirty = TRUE;
oh->mesg[idx].raw_size += delta;
@@ -2626,7 +2625,7 @@ H5O_alloc_extend_chunk(H5F_t *f, H5O_t *oh, unsigned chunkno, size_t size)
delta = MAX(H5O_MIN_SIZE, aligned_size+H5O_SIZEOF_MSGHDR(f));
delta = H5O_ALIGN(delta);
- if( H5MF_reserve(f, delta) < 0 )
+ if( H5MF_reserve(f, (hsize_t)delta) < 0 )
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "unable to reserve space in file");
/* create a new null message */
@@ -2768,7 +2767,7 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
assert (size == H5O_ALIGN (size));
/* Reserve space in the file to hold the new chunk */
- if( H5MF_reserve(f, size) < 0 )
+ if( H5MF_reserve(f, (hsize_t)size) < 0 )
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "unable to reserve space in file for new chunk");
/*
@@ -3072,7 +3071,7 @@ done:
*-------------------------------------------------------------------------
*/
size_t
-H5O_raw_size(hid_t type_id, H5F_t *f, const void *mesg)
+H5O_raw_size(unsigned type_id, H5F_t *f, const void *mesg)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
size_t ret_value; /* Return value */
@@ -3080,7 +3079,7 @@ H5O_raw_size(hid_t type_id, H5F_t *f, const void *mesg)
FUNC_ENTER_NOAPI(H5O_raw_size,0);
/* Check args */
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert (type);
assert (type->raw_size);
@@ -3116,7 +3115,7 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5O_get_share(hid_t type_id, H5F_t *f, const void *mesg, H5O_shared_t *share)
+H5O_get_share(unsigned type_id, H5F_t *f, const void *mesg, H5O_shared_t *share)
{
const H5O_class_t *type; /* Actual H5O class type for the ID */
herr_t ret_value; /* Return value */
@@ -3124,7 +3123,7 @@ H5O_get_share(hid_t type_id, H5F_t *f, const void *mesg, H5O_shared_t *share)
FUNC_ENTER_NOAPI(H5O_get_share,FAIL);
/* Check args */
- assert(type_id>=0 && type_id<(hid_t)(sizeof(message_type_g)/sizeof(message_type_g[0])));
+ assert(type_id<NELMTS(message_type_g));
type=message_type_g[type_id]; /* map the type ID to the actual type object */
assert (type);
assert (type->get_share);
diff --git a/src/H5Oefl.c b/src/H5Oefl.c
index e77a691..1f389ce 100644
--- a/src/H5Oefl.c
+++ b/src/H5Oefl.c
@@ -92,10 +92,11 @@ H5O_efl_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p, H5O_shared_t UNUSED *s
H5O_efl_t *mesg = NULL;
int version;
const char *s = NULL;
+ const H5HL_t *heap;
size_t u; /* Local index variable */
void *ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5O_efl_decode, NULL);
+ FUNC_ENTER_NOAPI_NOINIT(H5O_efl_decode);
/* Check args */
assert(f);
@@ -121,10 +122,19 @@ H5O_efl_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p, H5O_shared_t UNUSED *s
/* Heap address */
H5F_addr_decode(f, &p, &(mesg->heap_addr));
+
#ifndef NDEBUG
assert (H5F_addr_defined(mesg->heap_addr));
- s = H5HL_peek (f, dxpl_id, mesg->heap_addr, 0);
+
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, mesg->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "unable to read protect link value")
+
+ s = H5HL_offset_into(f, heap, 0);
+
assert (s && !*s);
+
+ if (H5HL_unprotect(f, dxpl_id, heap, mesg->heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "unable to read unprotect link value")
#endif
/* Decode the file list */
@@ -134,9 +144,17 @@ H5O_efl_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p, H5O_shared_t UNUSED *s
for (u=0; u<mesg->nused; u++) {
/* Name */
H5F_DECODE_LENGTH (f, p, mesg->slot[u].name_offset);
- s = H5HL_peek(f, dxpl_id, mesg->heap_addr, mesg->slot[u].name_offset);
+
+ if (NULL == (heap = H5HL_protect(f, dxpl_id, mesg->heap_addr)))
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "unable to read protect link value")
+
+ s = H5HL_offset_into(f, heap, mesg->slot[u].name_offset);
assert (s && *s);
mesg->slot[u].name = H5MM_xstrdup (s);
+ assert(mesg->slot[u].name);
+
+ if (H5HL_unprotect(f, dxpl_id, heap, mesg->heap_addr) < 0)
+ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "unable to read unprotect link value")
/* File offset */
H5F_DECODE_LENGTH (f, p, mesg->slot[u].offset);
@@ -184,9 +202,8 @@ H5O_efl_encode(H5F_t *f, uint8_t *p, const void *_mesg)
{
const H5O_efl_t *mesg = (const H5O_efl_t *)_mesg;
size_t u; /* Local index variable */
- herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5O_efl_encode, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_efl_encode);
/* check args */
assert(f);
@@ -223,8 +240,7 @@ H5O_efl_encode(H5F_t *f, uint8_t *p, const void *_mesg)
H5F_ENCODE_LENGTH (f, p, mesg->slot[u].size);
}
-done:
- FUNC_LEAVE_NOAPI(ret_value);
+ FUNC_LEAVE_NOAPI(SUCCEED);
}
@@ -253,7 +269,7 @@ H5O_efl_copy(const void *_mesg, void *_dest)
size_t u; /* Local index variable */
void *ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5O_efl_copy, NULL);
+ FUNC_ENTER_NOAPI_NOINIT(H5O_efl_copy);
/* check args */
assert(mesg);
@@ -310,7 +326,7 @@ H5O_efl_size(H5F_t *f, const void *_mesg)
const H5O_efl_t *mesg = (const H5O_efl_t *) _mesg;
size_t ret_value = 0;
- FUNC_ENTER_NOAPI(H5O_efl_size, 0);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_efl_size);
/* check args */
assert(f);
@@ -324,7 +340,6 @@ H5O_efl_size(H5F_t *f, const void *_mesg)
H5F_SIZEOF_SIZE(f) + /*file offset */
H5F_SIZEOF_SIZE(f)); /*file size */
-done:
FUNC_LEAVE_NOAPI(ret_value);
}
@@ -349,9 +364,8 @@ H5O_efl_reset(void *_mesg)
{
H5O_efl_t *mesg = (H5O_efl_t *) _mesg;
size_t u; /* Local index variable */
- herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5O_efl_reset, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_efl_reset);
/* check args */
assert(mesg);
@@ -364,8 +378,7 @@ H5O_efl_reset(void *_mesg)
if(mesg->slot)
mesg->slot = H5MM_xfree(mesg->slot);
-done:
- FUNC_LEAVE_NOAPI(ret_value);
+ FUNC_LEAVE_NOAPI(SUCCEED);
}
@@ -391,7 +404,7 @@ H5O_efl_total_size (H5O_efl_t *efl)
{
hsize_t ret_value = 0, tmp;
- FUNC_ENTER_NOAPI(H5O_efl_total_size, 0);
+ FUNC_ENTER_NOAPI_NOINIT(H5O_efl_total_size);
if (efl->nused>0 &&
H5O_EFL_UNLIMITED==efl->slot[efl->nused-1].size) {
@@ -443,7 +456,7 @@ H5O_efl_read (const H5O_efl_t *efl, haddr_t addr, size_t size, uint8_t *buf)
size_t u; /* Local index variable */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5O_efl_read, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT(H5O_efl_read);
/* Check args */
assert (efl && efl->nused>0);
@@ -529,7 +542,7 @@ H5O_efl_write (const H5O_efl_t *efl, haddr_t addr, size_t size, const uint8_t *b
size_t u; /* Local index variable */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5O_efl_write, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT(H5O_efl_write);
/* Check args */
assert (efl && efl->nused>0);
@@ -765,9 +778,8 @@ H5O_efl_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_mesg, FILE * s
const H5O_efl_t *mesg = (const H5O_efl_t *) _mesg;
char buf[64];
size_t u;
- herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5O_efl_debug, FAIL);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_efl_debug);
/* check args */
assert(f);
@@ -804,6 +816,5 @@ H5O_efl_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_mesg, FILE * s
(unsigned long)(mesg->slot[u].size));
}
-done:
- FUNC_LEAVE_NOAPI(ret_value);
+ FUNC_LEAVE_NOAPI(SUCCEED);
}
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index 8992bb4..9b05474 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -233,16 +233,16 @@ H5_DLL herr_t H5O_create(H5F_t *f, hid_t dxpl_id, size_t size_hint,
H5_DLL herr_t H5O_open(H5G_entry_t *ent);
H5_DLL herr_t H5O_close(H5G_entry_t *ent);
H5_DLL int H5O_link(const H5G_entry_t *ent, int adjust, hid_t dxpl_id);
-H5_DLL int H5O_count(H5G_entry_t *ent, hid_t type_id, hid_t dxpl_id);
-H5_DLL htri_t H5O_exists(H5G_entry_t *ent, hid_t type_id, int sequence,
+H5_DLL int H5O_count(H5G_entry_t *ent, unsigned type_id, hid_t dxpl_id);
+H5_DLL htri_t H5O_exists(H5G_entry_t *ent, unsigned type_id, int sequence,
hid_t dxpl_id);
-H5_DLL void *H5O_read(H5G_entry_t *ent, hid_t type_id, int sequence,
+H5_DLL void *H5O_read(H5G_entry_t *ent, unsigned type_id, int sequence,
void *mesg, hid_t dxpl_id);
-H5_DLL int H5O_modify(H5G_entry_t *ent, hid_t type_id,
+H5_DLL int H5O_modify(H5G_entry_t *ent, unsigned type_id,
int overwrite, unsigned flags, unsigned update_time, const void *mesg, hid_t dxpl_id);
H5_DLL struct H5O_t * H5O_protect(H5G_entry_t *ent, hid_t dxpl_id);
H5_DLL herr_t H5O_unprotect(H5G_entry_t *ent, struct H5O_t *oh, hid_t dxpl_id);
-H5_DLL int H5O_append(H5F_t *f, hid_t dxpl_id, struct H5O_t *oh, hid_t type_id,
+H5_DLL int H5O_append(H5F_t *f, hid_t dxpl_id, struct H5O_t *oh, unsigned type_id,
unsigned flags, const void *mesg);
H5_DLL herr_t H5O_touch(H5G_entry_t *ent, hbool_t force, hid_t dxpl_id);
H5_DLL herr_t H5O_touch_oh(H5F_t *f, struct H5O_t *oh, hbool_t force);
@@ -250,13 +250,13 @@ H5_DLL herr_t H5O_touch_oh(H5F_t *f, struct H5O_t *oh, hbool_t force);
H5_DLL herr_t H5O_bogus(H5G_entry_t *ent, hid_t dxpl_id);
H5_DLL herr_t H5O_bogus_oh(H5F_t *f, struct H5O_t *oh);
#endif /* H5O_ENABLE_BOGUS */
-H5_DLL herr_t H5O_remove(H5G_entry_t *ent, hid_t type_id, int sequence,
+H5_DLL herr_t H5O_remove(H5G_entry_t *ent, unsigned type_id, int sequence,
hid_t dxpl_id);
-H5_DLL herr_t H5O_reset(hid_t type_id, void *native);
-H5_DLL void *H5O_free(hid_t type_id, void *mesg);
-H5_DLL void *H5O_copy(hid_t type_id, const void *mesg, void *dst);
-H5_DLL size_t H5O_raw_size(hid_t type_id, H5F_t *f, const void *mesg);
-H5_DLL herr_t H5O_get_share(hid_t type_id, H5F_t *f, const void *mesg, H5O_shared_t *share);
+H5_DLL herr_t H5O_reset(unsigned type_id, void *native);
+H5_DLL void *H5O_free(unsigned type_id, void *mesg);
+H5_DLL void *H5O_copy(unsigned type_id, const void *mesg, void *dst);
+H5_DLL size_t H5O_raw_size(unsigned type_id, H5F_t *f, const void *mesg);
+H5_DLL herr_t H5O_get_share(unsigned type_id, H5F_t *f, const void *mesg, H5O_shared_t *share);
H5_DLL herr_t H5O_delete(H5F_t *f, hid_t dxpl_id, haddr_t addr);
H5_DLL herr_t H5O_get_info(H5G_entry_t *ent, H5O_stat_t *ostat, hid_t dxpl_id);
H5_DLL herr_t H5O_debug_id(hid_t type_id, H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream, int indent, int fwidth);
diff --git a/src/H5private.h b/src/H5private.h
index c37decd..71b09f6 100644
--- a/src/H5private.h
+++ b/src/H5private.h
@@ -434,6 +434,7 @@
#ifndef LLONG_MAX
# define LLONG_MAX ((long_long)(((unsigned long_long)1 \
<<(8*sizeof(long_long)-1))-1))
+# define LLONG_MIN ((long_long)(-LLONG_MAX)-1)
# define ULLONG_MAX ((unsigned long_long)((long_long)(-1)))
#endif
#ifndef SIZET_MAX
@@ -450,15 +451,6 @@
#define HSSIZET_MIN (~(HSSIZET_MAX))
/*
- * Some compilers have problems declaring auto variables that point
- * to string constants. Use the CONSTR() macro so it's easy to fix
- * those compilers.
- */
-#ifndef CONSTR
-# define CONSTR(VAR,STR) static const char VAR[]=STR
-#endif
-
-/*
* A macro to portably increment enumerated types.
*/
#ifndef H5_INC_ENUM
@@ -489,16 +481,16 @@
* A macro for detecting over/under-flow when assigning between types
*/
#ifndef NDEBUG
-#define H5_ASSIGN_OVERFLOW(var,expr,vartype,casttype) \
+#define H5_ASSIGN_OVERFLOW(var,expr,exprtype,vartype) \
{ \
- vartype _tmp_overflow=(vartype)(expr); \
- casttype _tmp_overflow2=(casttype)(_tmp_overflow); \
- assert((casttype)_tmp_overflow==_tmp_overflow2); \
+ exprtype _tmp_overflow=(exprtype)(expr); \
+ vartype _tmp_overflow2=(vartype)(_tmp_overflow); \
+ assert((vartype)_tmp_overflow==_tmp_overflow2); \
(var)=_tmp_overflow2; \
}
#else /* NDEBUG */
-#define H5_ASSIGN_OVERFLOW(var,expr,vartype,casttype) \
- (var)=(casttype)(expr);
+#define H5_ASSIGN_OVERFLOW(var,expr,exprtype,vartype) \
+ (var)=(vartype)(expr);
#endif /* NDEBUG */
/*
@@ -578,6 +570,7 @@ H5_DLL void H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds);
#endif /* __MWERKS __ */
#define HDexp(X) exp(X)
#define HDfabs(X) fabs(X)
+/* use ABS() because fabsf() fabsl() are not common yet. */
#define HDfabsf(X) ABS(X)
#define HDfabsl(X) ABS(X)
#define HDfclose(F) fclose(F)
@@ -589,7 +582,11 @@ H5_DLL void H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds);
#define HDfgetc(F) fgetc(F)
#define HDfgetpos(F,P) fgetpos(F,P)
#define HDfgets(S,N,F) fgets(S,N,F)
+#ifdef WIN32
+#define HDfileno(F) _fileno(F)
+#else /* WIN32 */
#define HDfileno(F) fileno(F)
+#endif /* WIN32 */
#define HDfloor(X) floor(X)
#define HDfmod(X,Y) fmod(X,Y)
#define HDfopen(S,M) fopen(S,M)
@@ -979,9 +976,13 @@ extern H5_debug_t H5_debug_g;
#define H5TRACE9(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
#A4,A4,#A5,A5,#A6,A6,#A7,A7,#A8,A8)
-#define H5TRACE10(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9) RTYPE=R; \
+#define H5TRACE10(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
#A4,A4,#A5,A5,#A6,A6,#A7,A7,#A8,A8,#A9,A9)
+#define H5TRACE11(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) RTYPE=R; \
+ CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
+ #A4,A4,#A5,A5,#A6,A6,#A7,A7,#A8,A8,#A9,A9, \
+ #A10,A10)
#define H5TRACE_RETURN(V) if (RTYPE) { \
H5_trace(&CALLTIME,FUNC,RTYPE,NULL,V); \
RTYPE=NULL; \
@@ -999,6 +1000,7 @@ extern H5_debug_t H5_debug_g;
#define H5TRACE8(R,T,A0,A1,A2,A3,A4,A5,A6,A7) /*void*/
#define H5TRACE9(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8) /*void*/
#define H5TRACE10(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9) /*void*/
+#define H5TRACE11(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) /*void*/
#define H5TRACE_RETURN(V) /*void*/
#endif
@@ -1024,37 +1026,6 @@ H5_DLL double H5_trace(double *calltime, const char *func, const char *type, ...
*
* Modifications:
*
- * Robb Matzke, 4 Aug 1997
- * The `interface_init_func' can be the null pointer. Changed
- * HGOTO_ERROR() to HRETURN_ERROR() since no clean-up needs to occur
- * when an error is detected at this point since this must be the
- * first executable statement in a function. This allows functions
- * to omit the `done:' label when convenient to do so.
- *
- * Robb Matzke, 4 Aug 1997
- * The pablo mask comes from the constant PABLO_MASK defined on
- * a per-file basis. The `pablo_func_id' is generated from the
- * `func_name' argument by prepending an `ID_' to the name. The
- * pablo function identifier should be saved in a local variable
- * so FUNC_LEAVE() can access it.
- *
- * Robb Matzke, 4 Aug 1997
- * It is safe to call this function even inside various library
- * initializing functions. Infinite recursion is no longer a
- * danger.
- *
- * Robb Matzke, 3 Dec 1997
- * The interface initialization function is no longer passed as an
- * argument unless the `FUNC_ENTER_INIT' form is called. Instead, the
- * function comes from the `INTERFACE_INIT' constant which must be
- * defined in every source file.
- *
- * Robb Matzke, 17 Jun 1998
- * Added auto variable RTYPE which is initialized by the tracing macros.
- *
- * Quincey Koziol, 28 May 2002
- * Split FUNC_ENTER macro into FUNC_ENTER_API, FUNC_ENTER_NOAPI and
- * FUNC_ENTER_NOAPI_NOINIT.
*-------------------------------------------------------------------------
*/
@@ -1115,7 +1086,6 @@ extern H5_api_t H5_g;
/* extern global variables */
extern hbool_t H5_libinit_g; /* Has the library been initialized? */
-
/* Macros for accessing the global variables */
#define H5_INIT_GLOBAL H5_libinit_g
@@ -1140,7 +1110,7 @@ extern hbool_t H5_MPEinit_g; /* Has the MPE Library been initialized? */
/* Check if the function name is correct (if the compiler supports __FUNCTION__) */
#ifdef H5_HAVE_FUNCTION
#define H5_CHECK_FUNCNAME(func_name) \
- assert(func_name && !HDstrcmp(#func_name, __FUNCTION__))
+ assert(!HDstrcmp(#func_name, __FUNCTION__))
#else /* H5_HAVE_FUNCTION */
#define H5_CHECK_FUNCNAME(func_name) \
assert(func_name)
@@ -1159,8 +1129,8 @@ extern hbool_t H5_MPEinit_g; /* Has the MPE Library been initialized? */
PABLO_TRACE_ON (PABLO_MASK, pablo_func_id)
#define FUNC_ENTER_COMMON(func_name,asrt) \
- CONSTR (FUNC, #func_name); \
- FUNC_ENTER_COMMON_NOFUNC(func_name,asrt); \
+ static const char FUNC[]=#func_name; \
+ FUNC_ENTER_COMMON_NOFUNC(func_name,asrt);
/* Threadsafety initialization code for API routines */
#define FUNC_ENTER_API_THREADSAFE \
@@ -1267,7 +1237,7 @@ extern hbool_t H5_MPEinit_g; /* Has the MPE Library been initialized? */
H5_INIT_GLOBAL = TRUE; \
if (H5_init_library()<0) \
HGOTO_ERROR (H5E_FUNC, H5E_CANTINIT, err, \
- "library initialization failed"); \
+ "library initialization failed") \
} \
\
/* Initialize this interface or bust */ \
diff --git a/test/lheap.c b/test/lheap.c
index 04ca275..4aee352 100644
--- a/test/lheap.c
+++ b/test/lheap.c
@@ -110,14 +110,24 @@ main(void)
goto error;
}
for (i=0; i<NOBJS; i++) {
+ const H5HL_t *heap = NULL;
+
sprintf(buf, "%03d-", i);
for (j=4; j<i; j++) buf[j] = '0' + j%10;
if (j>4) buf[j] = '\0';
- if (NULL==(s=H5HL_peek(f, H5P_DATASET_XFER_DEFAULT, heap_addr, obj[i]))) {
+
+ if (NULL == (heap = H5HL_protect(f, H5P_DATASET_XFER_DEFAULT, heap_addr))) {
H5_FAILED();
H5Eprint(stdout);
goto error;
}
+
+ if (NULL == (s = H5HL_offset_into(f, heap, obj[i]))) {
+ H5_FAILED();
+ H5Eprint(stdout);
+ goto error;
+ }
+
if (strcmp(s, buf)) {
H5_FAILED();
printf(" i=%d, heap offset=%lu\n", i, (unsigned long)(obj[i]));
@@ -125,13 +135,18 @@ main(void)
printf(" ans: \"%s\"\n", buf);
goto error;
}
+
+ if (H5HL_unprotect(f, H5P_DATASET_XFER_DEFAULT, heap, heap_addr) < 0) {
+ H5_FAILED();
+ H5Eprint(stdout);
+ goto error;
+ }
}
if (H5Fclose(file)<0) goto error;
PASSED();
- h5_cleanup(FILENAME, fapl);
-
puts("All local heap tests passed.");
+ h5_cleanup(FILENAME, fapl);
return 0;
error:
diff --git a/test/reserved.c b/test/reserved.c
index 3fb5827..ff2315b 100755
--- a/test/reserved.c
+++ b/test/reserved.c
@@ -34,88 +34,90 @@
*
*-------------------------------------------------------------------------
*/
-herr_t rsrv_heap()
+static herr_t
+rsrv_heap(void)
{
- hid_t file_id, dataset_id, dataspace_id;
- hid_t pfc_id;
- hsize_t dims[1] = {1};
- herr_t ret_value = 0;
- char dset_name[10];
- int i;
+ hid_t file_id, dataset_id, dataspace_id;
+ hid_t pfc_id;
+ hsize_t dims[1] = {1};
+ herr_t ret_value = 0;
+ char dset_name[10];
+ int i;
TESTING("Reserving file space for heap");
- /* Create a new file. */
- pfc_id = H5Pcreate(H5P_FILE_CREATE);
- H5Pset_userblock(pfc_id, (int)0);
- H5Pset_sym_k(pfc_id, (int)1, (int)1);
- H5Pset_istore_k(pfc_id, (int)1);
- /* Set file address sizes to be very small. */
+ /* Create a new file. */
+ pfc_id = H5Pcreate(H5P_FILE_CREATE);
+ H5Pset_userblock(pfc_id, (hsize_t)0);
+ H5Pset_sym_k(pfc_id, 1, 1);
+ H5Pset_istore_k(pfc_id, 1);
+
+ /* Set file address sizes to be very small. */
H5Pset_sizes(pfc_id, (size_t)2,(size_t)2);
- file_id = H5Fcreate("rsrv_heap", H5F_ACC_TRUNC, pfc_id, H5P_DEFAULT);
+ file_id = H5Fcreate("rsrv_heap", H5F_ACC_TRUNC, pfc_id, H5P_DEFAULT);
- /* Write datasets until the file is full, at which point HDF5
- * should throw an error.
- */
- for (i = 0; i < 200; i++)
- {
- H5E_BEGIN_TRY {
- dataspace_id = H5Screate_simple(1, dims, dims);
- } H5E_END_TRY
+ /* Write datasets until the file is full, at which point HDF5
+ * should throw an error.
+ */
+ for (i = 0; i < 200; i++)
+ {
+ H5E_BEGIN_TRY {
+ dataspace_id = H5Screate_simple(1, dims, dims);
+ } H5E_END_TRY
- sprintf(dset_name, "Dset %d", i);
+ sprintf(dset_name, "Dset %d", i);
- H5E_BEGIN_TRY {
- dataset_id = H5Dcreate(file_id, dset_name, H5T_NATIVE_INT, dataspace_id, H5P_DEFAULT);
- } H5E_END_TRY
+ H5E_BEGIN_TRY {
+ dataset_id = H5Dcreate(file_id, dset_name, H5T_NATIVE_INT, dataspace_id, H5P_DEFAULT);
+ } H5E_END_TRY
- if(dataset_id < 0)
- break;
+ if(dataset_id < 0)
+ break;
- H5E_BEGIN_TRY {
- H5Dwrite(dataset_id, H5T_NATIVE_INT, dataspace_id, dataspace_id, H5P_DEFAULT, &i);
- } H5E_END_TRY
+ H5E_BEGIN_TRY {
+ H5Dwrite(dataset_id, H5T_NATIVE_INT, dataspace_id, dataspace_id, H5P_DEFAULT, &i);
+ } H5E_END_TRY
- H5Dclose(dataset_id);
- H5Sclose(dataspace_id);
- }
+ H5Dclose(dataset_id);
+ H5Sclose(dataspace_id);
+ }
- /* Close the file, property lists, and library */
+ /* Close the file, property lists, and library */
H5Fclose(file_id);
- H5Pclose (pfc_id);
- H5close();
+ H5Pclose(pfc_id);
+ H5close();
- /* The loop should have broken before completing--the file should not have had
- * enough address space to hold 200 datasets (or this test needs to be updated!).
- */
- if(i == 200)
+ /* The loop should have broken before completing--the file should not have had
+ * enough address space to hold 200 datasets (or this test needs to be updated!).
+ */
+ if(i == 200)
{
- ret_value = -1;
- H5_FAILED();
+ ret_value = 1;
+ H5_FAILED();
}
- /* Re-open the library and try to read a dataset from the file we created */
- H5open();
+ /* Re-open the library and try to read a dataset from the file we created */
+ H5open();
- sprintf(dset_name, "Dset %d", i - 2);
+ sprintf(dset_name, "Dset %d", i - 2);
- file_id = H5Fopen("rsrv_heap", H5F_ACC_RDONLY, H5P_DEFAULT);
+ file_id = H5Fopen("rsrv_heap", H5F_ACC_RDONLY, H5P_DEFAULT);
- dataset_id = H5Dopen(file_id, dset_name);
+ dataset_id = H5Dopen(file_id, dset_name);
- /* If we can read a dataset from the file, the file has been flushed to disk
- * (if the heap or object headers weren't flushed, the file would be empty).
- */
- if(dataset_id == H5I_BADID)
- {
- ret_value = -1;
- H5_FAILED();
- }
+ /* If we can read a dataset from the file, the file has been flushed to disk
+ * (if the heap or object headers weren't flushed, the file would be empty).
+ */
+ if(dataset_id == H5I_BADID)
+ {
+ ret_value = 1;
+ H5_FAILED();
+ }
- H5Dclose(dataset_id);
- H5Fclose(file_id);
- remove("rsrv_heap");
+ H5Dclose(dataset_id);
+ H5Fclose(file_id);
+ HDremove("rsrv_heap");
if(ret_value == 0)
{
@@ -145,35 +147,35 @@ herr_t rsrv_heap()
*
*-------------------------------------------------------------------------
*/
-herr_t rsrv_ohdr()
+static herr_t
+rsrv_ohdr(void)
{
- hid_t file_id, dataset_id, dataspace_id;
- hid_t pfc_id, aid, attr_id;
- hsize_t dims[2];
- herr_t status, ret_value = 0;
- int attrval[4][6];
- char *basenm = "attr";
- char attrname[20], nm_suf[10];
- int i;
+ hid_t file_id, dataset_id, dataspace_id;
+ hid_t pfc_id, aid, attr_id;
+ hsize_t dims[2];
+ herr_t status, ret_value = 0;
+ int attrval[4][6];
+ char attrname[20];
+ int i;
TESTING("Reserving file space for object headers");
- /* Create a new file using default properties. */
- pfc_id = H5Pcreate(H5P_FILE_CREATE);
- H5Pset_userblock(pfc_id, (int)0);
- H5Pset_sym_k(pfc_id, (int)1, (int)1);
- H5Pset_istore_k(pfc_id, (int)1);
- H5Pset_sizes(pfc_id, (size_t)2,(size_t)2);
+ /* Create a new file using default properties. */
+ pfc_id = H5Pcreate(H5P_FILE_CREATE);
+ H5Pset_userblock(pfc_id, (hsize_t)0);
+ H5Pset_sym_k(pfc_id, 1, 1);
+ H5Pset_istore_k(pfc_id, 1);
+ H5Pset_sizes(pfc_id, (size_t)2,(size_t)2);
- file_id = H5Fcreate("rsrv_ohdr", H5F_ACC_TRUNC, pfc_id, H5P_DEFAULT);
+ file_id = H5Fcreate("rsrv_ohdr", H5F_ACC_TRUNC, pfc_id, H5P_DEFAULT);
- /* Create the data space for the dataset. */
- dims[0] = 4;
- dims[1] = 6;
- dataspace_id = H5Screate_simple(2, dims, NULL);
+ /* Create the data space for the dataset. */
+ dims[0] = 4;
+ dims[1] = 6;
+ dataspace_id = H5Screate_simple(2, dims, NULL);
- /* Create the dataset. */
- dataset_id = H5Dcreate(file_id, "/dset", H5T_STD_I32BE, dataspace_id, H5P_DEFAULT);
+ /* Create the dataset. */
+ dataset_id = H5Dcreate(file_id, "/dset", H5T_STD_I32BE, dataspace_id, H5P_DEFAULT);
for(i=0; i<6; i++)
{
@@ -183,63 +185,61 @@ herr_t rsrv_ohdr()
attrval[3][i] = 3;
}
- for (i = 0; i< 2000; i++)
- {
- strcpy(attrname, basenm);
- sprintf(nm_suf, "%d", i);
- strcat(attrname, nm_suf);
- H5E_BEGIN_TRY{
- aid = H5Screate_simple(2, dims, NULL);
- attr_id = H5Acreate (dataset_id, attrname, H5T_STD_I32BE, aid, H5P_DEFAULT);
- status = H5Awrite(attr_id, H5T_NATIVE_INT, attrval);
- status = H5Aclose(attr_id);
- }H5E_END_TRY
+ for (i = 0; i< 2000; i++)
+ {
+ sprintf(attrname, "attr %d", i);
+ H5E_BEGIN_TRY{
+ aid = H5Screate_simple(2, dims, NULL);
+ attr_id = H5Acreate (dataset_id, attrname, H5T_STD_I32BE, aid, H5P_DEFAULT);
+ status = H5Awrite(attr_id, H5T_NATIVE_INT, attrval);
+ status = H5Aclose(attr_id);
+ } H5E_END_TRY
if(status < 0)
break;
- }
+ }
- /* End access to the dataset and dataspace and release resources. */
- H5Dclose(dataset_id);
- H5Pclose (pfc_id);
- H5Sclose(dataspace_id);
+ /* End access to the dataset and dataspace and release resources. */
+ H5Dclose(dataset_id);
+ H5Pclose (pfc_id);
+ H5Sclose(dataspace_id);
- /* Close the file and the library. */
- H5Fclose(file_id);
- H5close();
+ /* Close the file and the library. */
+ H5Fclose(file_id);
+ H5close();
- /* The loop should have broken before completing--the file should not have had
- * enough address space to hold 2000 attributes (or this test needs to be updated!).
- */
+ /* The loop should have broken before completing--the file should not have had
+ * enough address space to hold 2000 attributes (or this test needs to be updated!).
+ */
if(i == 2000)
{
- ret_value = -1;
+ ret_value = 1;
H5_FAILED();
}
- /* Re-open the library and try to read a dataset from the file we created */
- H5open();
+ /* Re-open the library and try to read a dataset from the file we created */
+ H5open();
- file_id = H5Fopen("rsrv_ohdr", H5F_ACC_RDONLY, H5P_DEFAULT);
+ file_id = H5Fopen("rsrv_ohdr", H5F_ACC_RDONLY, H5P_DEFAULT);
- dataset_id = H5Dopen(file_id, "/dset");
+ dataset_id = H5Dopen(file_id, "/dset");
- /* If we can read the dataset from the file, the file has been flushed to disk
- * (if the heap or object headers weren't flushed, the file would be empty).
- */
- if(dataset_id == H5I_BADID)
- {
- H5_FAILED();
- ret_value = -1;
- }
+ /* If we can read the dataset from the file, the file has been flushed to disk
+ * (if the heap or object headers weren't flushed, the file would be empty).
+ */
+ if(dataset_id == H5I_BADID)
+ {
+ ret_value = 1;
+ H5_FAILED();
+ }
if(ret_value == 0)
PASSED();
- H5Dclose(dataset_id);
- H5Fclose(file_id);
+ H5Dclose(dataset_id);
+ H5Fclose(file_id);
- remove("rsrv_ohdr");
+ HDremove("rsrv_ohdr");
return ret_value;
}
@@ -266,11 +266,14 @@ herr_t rsrv_ohdr()
*
*-------------------------------------------------------------------------
*/
-herr_t rsrv_vlen()
+static herr_t
+rsrv_vlen(void)
{
hid_t file_id, dataset_id, dataspace_id, type_id;
hid_t pfc_id, mem_space_id;
- hsize_t dims[1], start[1], count[1];
+ hssize_t offset[1];
+ hssize_t start[1];
+ hsize_t dims[1], count[1];
herr_t status, ret_value = 0;
int i;
int write_buf[20];
@@ -280,9 +283,9 @@ herr_t rsrv_vlen()
/* Create a new file using default properties. */
pfc_id = H5Pcreate(H5P_FILE_CREATE);
- H5Pset_userblock(pfc_id, (int)0);
- H5Pset_sym_k(pfc_id, (int)1, (int)1);
- H5Pset_istore_k(pfc_id, (int)1);
+ H5Pset_userblock(pfc_id, (hsize_t)0);
+ H5Pset_sym_k(pfc_id, 1, 1);
+ H5Pset_istore_k(pfc_id, 1);
H5Pset_sizes(pfc_id, (size_t)2,(size_t)2);
file_id = H5Fcreate("rsrv_vlen", H5F_ACC_TRUNC, pfc_id, H5P_DEFAULT);
@@ -315,11 +318,11 @@ herr_t rsrv_vlen()
{
vlen_data.len = (i%20) + 1;
- dims[0] = i;
- H5Soffset_simple(dataspace_id, dims);
+ offset[0] = i;
+ H5Soffset_simple(dataspace_id, offset);
H5E_BEGIN_TRY
- status = H5Dwrite(dataset_id, type_id, mem_space_id, dataspace_id, H5P_DEFAULT, &vlen_data);
+ status = H5Dwrite(dataset_id, type_id, mem_space_id, dataspace_id, H5P_DEFAULT, &vlen_data);
H5E_END_TRY
if(status < 0)
@@ -342,7 +345,7 @@ herr_t rsrv_vlen()
*/
if(i == 2000)
{
- ret_value = -1;
+ ret_value = 1;
H5_FAILED();
}
@@ -358,8 +361,8 @@ herr_t rsrv_vlen()
*/
if(dataset_id == H5I_BADID)
{
+ ret_value = 1;
H5_FAILED();
- ret_value = -1;
}
if(ret_value == 0)
@@ -368,7 +371,7 @@ herr_t rsrv_vlen()
H5Dclose(dataset_id);
H5Fclose(file_id);
- remove("rsrv_vlen");
+ HDremove("rsrv_vlen");
return ret_value;
}
@@ -392,10 +395,12 @@ herr_t rsrv_vlen()
int
main(void)
{
- rsrv_ohdr();
- rsrv_heap();
- rsrv_vlen();
+ int num_errs=0;
+
+ num_errs+=rsrv_ohdr();
+ num_errs+=rsrv_heap();
+ num_errs+=rsrv_vlen();
- return 0;
+ return num_errs;
}
diff --git a/test/titerate.c b/test/titerate.c
index aea951e..18a7246 100644
--- a/test/titerate.c
+++ b/test/titerate.c
@@ -178,7 +178,7 @@ static void test_iter_group(void)
CHECK(ret, FAIL, "H5Fclose");
/* Sort the dataset names */
- qsort(dnames,NDATASETS,sizeof(char *),iter_strcmp);
+ HDqsort(dnames,NDATASETS,sizeof(char *),iter_strcmp);
/* Iterate through the datasets in the root group in various ways */
@@ -267,9 +267,8 @@ static void test_iter_group(void)
/* Test all objects in group, when callback always returns 0 */
info.command=RET_ZERO;
idx=0;
- if((ret=H5Giterate(file,"/",&idx,giter_cb,&info))>0) {
+ if((ret=H5Giterate(file,"/",&idx,giter_cb,&info))>0)
TestErrPrintf("Group iteration function didn't return zero correctly!\n");
- }
/* Test all objects in group, when callback always returns 1 */
/* This also tests the "restarting" ability, because the index changes */
@@ -287,29 +286,24 @@ static void test_iter_group(void)
/* Verify that the correct name is retrieved */
if(idx<=NDATASETS) {
- if(strcmp(info.name,dnames[idx-1])!=0) {
+ if(HDstrcmp(info.name,dnames[idx-1])!=0)
TestErrPrintf("Group iteration function didn't return one correctly for dataset #%d!\n",idx);
- } /* end if */
} /* end if */
else if(idx==(NDATASETS+1)) {
- if(strcmp(info.name,"dtype")!=0) {
+ if(HDstrcmp(info.name,"dtype")!=0)
TestErrPrintf("Group iteration function didn't return one correctly for group!\n");
- } /* end if */
} /* end if */
else if(idx==(NDATASETS+2)) {
- if(strcmp(info.name,"grp")!=0) {
+ if(HDstrcmp(info.name,"grp")!=0)
TestErrPrintf("Group iteration function didn't return one correctly for group!\n");
- } /* end if */
} /* end if */
- else {
+ else
TestErrPrintf("Group iteration function walked too far!\n");
- } /* end else */
}
VERIFY(ret,-1,"H5Giterate");
- if(i!=(NDATASETS+2)) {
+ if(i!=(NDATASETS+2))
TestErrPrintf("Group iteration function didn't perform multiple iterations correctly!\n");
- } /* end if */
/* Test all objects in group, when callback changes return value */
/* This also tests the "restarting" ability, because the index changes */
@@ -327,36 +321,31 @@ static void test_iter_group(void)
/* Verify that the correct name is retrieved */
if(idx<=NDATASETS) {
- if(strcmp(info.name,dnames[idx-1])!=0) {
+ if(HDstrcmp(info.name,dnames[idx-1])!=0)
TestErrPrintf("Group iteration function didn't return one correctly for dataset #%d!\n",idx);
- } /* end if */
} /* end if */
else if(idx==(NDATASETS+1)) {
- if(strcmp(info.name,"dtype")!=0) {
+ if(HDstrcmp(info.name,"dtype")!=0)
TestErrPrintf("Group iteration function didn't return one correctly for group!\n");
- } /* end if */
} /* end if */
else if(idx==(NDATASETS+2)) {
- if(strcmp(info.name,"grp")!=0) {
+ if(HDstrcmp(info.name,"grp")!=0)
TestErrPrintf("Group iteration function didn't return one correctly for group!\n");
- } /* end if */
} /* end if */
- else {
+ else
TestErrPrintf("Group iteration function walked too far!\n");
- } /* end else */
}
VERIFY(ret,-1,"H5Giterate");
- if(i!=42 || idx!=52) {
+ if(i!=42 || idx!=52)
TestErrPrintf("Group iteration function didn't perform multiple iterations correctly!\n");
- } /* end if */
ret=H5Fclose(file);
CHECK(ret, FAIL, "H5Fclose");
/* Free the dataset names */
for(i=0; i< NDATASETS; i++)
- free(dnames[i]);
+ HDfree(dnames[i]);
} /* test_iter_group() */
@@ -477,9 +466,8 @@ static void test_iter_attr(void)
/* Test all attributes on dataset, when callback always returns 0 */
info.command=RET_ZERO;
idx=0;
- if((ret=H5Aiterate(dataset,&idx,aiter_cb,&info))>0) {
+ if((ret=H5Aiterate(dataset,&idx,aiter_cb,&info))>0)
TestErrPrintf("Attribute iteration function didn't return zero correctly!\n");
- }
/* Test all attributes on dataset, when callback always returns 1 */
/* This also tests the "restarting" ability, because the index changes */
@@ -496,14 +484,12 @@ static void test_iter_attr(void)
VERIFY(idx,(unsigned)i,"H5Aiterate");
/* Verify that the correct name is retrieved */
- if(strcmp(info.name,anames[idx-1])!=0) {
+ if(HDstrcmp(info.name,anames[idx-1])!=0)
TestErrPrintf("Attribute iteration function didn't return one correctly!\n");
- } /* end if */
}
VERIFY(ret,-1,"H5Aiterate");
- if(i!=50 || idx!=50) {
+ if(i!=50 || idx!=50)
TestErrPrintf("Group iteration function didn't perform multiple iterations correctly!\n");
- } /* end if */
/* Test all attributes on dataset, when callback changes return value */
@@ -521,14 +507,12 @@ static void test_iter_attr(void)
VERIFY(idx,(unsigned)i+10,"H5Aiterate");
/* Verify that the correct name is retrieved */
- if(strcmp(info.name,anames[idx-1])!=0) {
+ if(HDstrcmp(info.name,anames[idx-1])!=0)
TestErrPrintf("Attribute iteration function didn't return changing correctly!\n");
- } /* end if */
}
VERIFY(ret,-1,"H5Aiterate");
- if(i!=40 || idx!=50) {
+ if(i!=40 || idx!=50)
TestErrPrintf("Group iteration function didn't perform multiple iterations correctly!\n");
- } /* end if */
ret=H5Fclose(file);
CHECK(ret, FAIL, "H5Fclose");
@@ -538,7 +522,7 @@ static void test_iter_attr(void)
/* Free the attribute names */
for(i=0; i< NATTR; i++)
- free(anames[i]);
+ HDfree(anames[i]);
} /* test_iter_attr() */
@@ -563,7 +547,7 @@ herr_t giter_cb2(hid_t loc_id, const char *name, void *opdata)
herr_t ret; /* Generic return value */
H5G_stat_t statbuf;
- if(strcmp(name,test_info->name)) {
+ if(HDstrcmp(name,test_info->name)) {
TestErrPrintf("name=%s, test_info=%s\n",name,test_info->name);
return(-1);
} /* end if */
@@ -774,8 +758,7 @@ static void test_grp_memb_funcs(void)
CHECK(ret, FAIL, "H5Fclose");
/* Sort the dataset names */
- qsort(dnames,NDATASETS+2,sizeof(char *),iter_strcmp);
-
+ HDqsort(dnames,NDATASETS+2,sizeof(char *),iter_strcmp);
/* Iterate through the datasets in the root group in various ways */
file=H5Fopen(DATAFILE, H5F_ACC_RDONLY, H5P_DEFAULT);
diff --git a/test/unlink.c b/test/unlink.c
index 123847a..f87b6fb 100644
--- a/test/unlink.c
+++ b/test/unlink.c
@@ -1821,7 +1821,7 @@ error:
static int
test_resurrect_dataset(void)
{
- hid_t f, s, d, fapl;
+ hid_t f=-1, s=-1, d=-1, fapl=-1;
char filename[1024];
TESTING("Resurrecting dataset after deletion");
generated by cgit v0.12 at 2024-07-26 13:38:31 (GMT)