summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/H5Aprivate.h3
-rw-r--r--src/H5Apublic.h1
-rw-r--r--src/H5D.c54
-rw-r--r--src/H5F.c74
-rw-r--r--src/H5Fprivate.h4
-rw-r--r--src/H5G.c1143
-rw-r--r--src/H5Gent.c68
-rw-r--r--src/H5Gnode.c181
-rw-r--r--src/H5Gpkg.h91
-rw-r--r--src/H5Gprivate.h43
-rw-r--r--src/H5Gpublic.h9
-rw-r--r--src/H5Gshad.c810
-rw-r--r--src/H5Gstab.c157
-rw-r--r--src/H5O.c179
-rw-r--r--src/H5Oprivate.h18
-rw-r--r--src/H5P.c4
-rw-r--r--src/H5private.h2
-rw-r--r--src/Makefile.in7
18 files changed, 926 insertions, 1922 deletions
diff --git a/src/H5Aprivate.h b/src/H5Aprivate.h
index 501c0f9..916ed89 100644
--- a/src/H5Aprivate.h
+++ b/src/H5Aprivate.h
@@ -63,7 +63,8 @@
#define H5A_DATATYPEID_HASHSIZE 64
#define H5A_DATASPACEID_HASHSIZE 64
#define H5A_DATASETID_HASHSIZE 64
-#define H5A_OID_HASHSIZE 64
+#define H5A_OID_HASHSIZE 64
+#define H5A_GROUPID_HASHSIZE 64
/* Atom information structure used */
typedef struct atom_info_struct_tag {
diff --git a/src/H5Apublic.h b/src/H5Apublic.h
index 7c0d1c1..60c4d40 100644
--- a/src/H5Apublic.h
+++ b/src/H5Apublic.h
@@ -38,6 +38,7 @@ typedef enum {
#ifndef NDEBUG
H5_TEMPLATE_MAX, /* Not really a group ID */
#endif
+ H5_GROUP, /* Group ID for Group objects */
H5_DATATYPE, /* Group ID for Datatype objects */
H5_DATASPACE, /* Group ID for Dataspace objects */
H5_DATASET, /* Group ID for Dataset objects */
diff --git a/src/H5D.c b/src/H5D.c
index 87e16d9..242cc8b 100644
--- a/src/H5D.c
+++ b/src/H5D.c
@@ -37,7 +37,7 @@ static char RcsId[] = "@(#)$Revision$";
*/
struct H5D_t {
H5F_t *file; /*file store for this object */
- H5G_entry_t *ent; /*cached object header stuff */
+ H5G_entry_t ent; /*cached object header stuff */
H5T_t *type; /*datatype of this dataset */
H5P_t *space; /*dataspace of this dataset */
H5D_create_t create_parms; /*creation parameters */
@@ -53,7 +53,7 @@ const H5D_create_t H5D_create_dflt = {
1, /* Chunk dimensions */
{1, 1, 1, 1, 1, 1, 1, 1, /* Chunk size. These default values....*/
1, 1, 1, 1, 1, 1, 1, 1, /*...are quite useless. Larger chunks..*/
- 1, 1, 1, 1, 1, 1, 1, 1, /*...produces fewer, but larger I/O.....*/
+ 1, 1, 1, 1, 1, 1, 1, 1, /*...produce fewer, but larger I/O......*/
1, 1, 1, 1, 1, 1, 1, 1}, /*...requests. */
};
@@ -576,26 +576,22 @@ H5D_create (H5F_t *f, const char *name, const H5T_t *type, const H5P_t *space,
/* Initialize the dataset object */
new_dset = H5MM_xcalloc (1, sizeof(H5D_t));
new_dset->file = f;
+ H5F_addr_undef (&(new_dset->ent.header));
new_dset->type = H5T_copy (type);
new_dset->space = H5P_copy (space);
new_dset->create_parms = *create_parms;
/*
- * Open (and create) a new file object and update the object header
- * immediately with the new information so when others access the dataset
- * they see the most current info. This `write through the dataset'
- * policy is used throughout this package, and because the object header
- * is cached it shouldn't cause any disk activity.
+ * Create (open for write access) an object header.
*/
- if (NULL==(new_dset->ent = H5G_create (f, name, H5D_MINHDR_SIZE))) {
+ if (H5O_create (f, 0, &(new_dset->ent))<0) {
HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
- "problem with the dataset name");
+ "unable to create dataset object header");
}
/* Update the type and space header messages */
- if (H5O_modify (f, NO_ADDR, new_dset->ent, H5O_DTYPE, 0,
- new_dset->type)<0 ||
- H5P_modify (f, new_dset->ent, new_dset->space)<0) {
+ if (H5O_modify (f, &(new_dset->ent), H5O_DTYPE, 0, new_dset->type)<0 ||
+ H5P_modify (f, &(new_dset->ent), new_dset->space)<0) {
HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
"can't update type or space header messages");
}
@@ -612,7 +608,7 @@ H5D_create (H5F_t *f, const char *name, const H5T_t *type, const H5P_t *space,
HGOTO_ERROR (H5E_DATASET, H5E_NOSPACE, NULL,
"can't allocate raw file storage");
}
- if (H5O_modify (f, NO_ADDR, new_dset->ent, H5O_CSTORE, 0,
+ if (H5O_modify (f, &(new_dset->ent), H5O_CSTORE, 0,
&(new_dset->storage.cstore))<0) {
HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
"can't update dataset object header");
@@ -639,7 +635,7 @@ H5D_create (H5F_t *f, const char *name, const H5T_t *type, const H5P_t *space,
HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
"can't initialize chunked storage");
}
- if (H5O_modify (f, NO_ADDR, new_dset->ent, H5O_ISTORE, 0,
+ if (H5O_modify (f, &(new_dset->ent), H5O_ISTORE, 0,
&(new_dset->storage.istore))<0) {
HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
"can't update dataset object header");
@@ -651,6 +647,11 @@ H5D_create (H5F_t *f, const char *name, const H5T_t *type, const H5P_t *space,
HGOTO_ERROR (H5E_DATASET, H5E_UNSUPPORTED, NULL, "not implemented yet");
}
+ /* Give the dataset a name */
+ if (H5G_insert (f, name, &(new_dset->ent))<0) {
+ HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL, "unable to name dataset");
+ }
+
/* Success */
ret_value = new_dset;
@@ -659,7 +660,9 @@ H5D_create (H5F_t *f, const char *name, const H5T_t *type, const H5P_t *space,
if (!ret_value && new_dset) {
if (new_dset->type) H5T_close (new_dset->type);
if (new_dset->space) H5P_close (new_dset->space);
- if (new_dset->ent) H5G_close (f, new_dset->ent);
+ if (H5F_addr_defined (&(new_dset->ent.header))) {
+ H5O_close (f, &(new_dset->ent));
+ }
new_dset->file = NULL;
H5MM_xfree (new_dset);
}
@@ -704,16 +707,20 @@ H5D_open (H5F_t *f, const char *name)
dataset = H5MM_xcalloc (1, sizeof(H5D_t));
dataset->file = f;
dataset->create_parms = H5D_create_dflt;
+ H5F_addr_undef (&(dataset->ent.header));
/* Open the dataset object */
- if (NULL==(dataset->ent=H5G_open (f, name))) {
+ if (H5G_find (f, name, NULL, &(dataset->ent))<0) {
HGOTO_ERROR (H5E_DATASET, H5E_NOTFOUND, NULL, "not found");
}
+ if (H5O_open (f, &(dataset->ent))<0) {
+ HGOTO_ERROR (H5E_DATASET, H5E_CANTOPENOBJ, NULL, "unable to open");
+ }
/* Get the type and space */
- if (NULL==(dataset->type = H5O_read (f, NO_ADDR, dataset->ent, H5O_DTYPE,
+ if (NULL==(dataset->type = H5O_read (f, &(dataset->ent), H5O_DTYPE,
0, NULL)) ||
- NULL==(dataset->space = H5P_read (f, dataset->ent))) {
+ NULL==(dataset->space = H5P_read (f, &(dataset->ent)))) {
HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
"can't load type of space info from dataset header");
}
@@ -724,12 +731,12 @@ H5D_open (H5F_t *f, const char *name)
* values are copied to the dataset create template so the user can query
* them.
*/
- if (H5O_read (dataset->file, NO_ADDR, dataset->ent, H5O_CSTORE, 0,
+ if (H5O_read (dataset->file, &(dataset->ent), H5O_CSTORE, 0,
&(dataset->storage.cstore))) {
/* Contiguous storage */
dataset->create_parms.layout = H5D_CONTIGUOUS;
- } else if (H5O_read (dataset->file, NO_ADDR, dataset->ent, H5O_ISTORE, 0,
+ } else if (H5O_read (dataset->file, &(dataset->ent), H5O_ISTORE, 0,
&(dataset->storage.istore))) {
/*
* Chunked storage. The creation template's dimension is one less than
@@ -755,7 +762,9 @@ H5D_open (H5F_t *f, const char *name)
done:
if (!ret_value && dataset) {
- if (dataset->ent) H5G_close (f, dataset->ent);
+ if (H5F_addr_defined (&(dataset->ent.header))) {
+ H5O_close (f, &(dataset->ent));
+ }
if (dataset->type) H5T_close (dataset->type);
if (dataset->space) H5P_close (dataset->space);
dataset->file = NULL;
@@ -799,8 +808,7 @@ H5D_close (H5D_t *dataset)
assert (dataset && dataset->file);
/* Close the dataset object */
- H5G_close (dataset->file, dataset->ent);
- dataset->ent = NULL;
+ H5O_close (dataset->file, &(dataset->ent));
/*
* Release dataset type and space - there isn't much we can do if one of
diff --git a/src/H5F.c b/src/H5F.c
index af3892b..c07ac38 100644
--- a/src/H5F.c
+++ b/src/H5F.c
@@ -417,14 +417,6 @@ H5F_new (H5F_file_t *shared)
/* Create a main cache */
H5AC_create (f, H5AC_NSLOTS);
-
- /* Create the shadow hash table */
- f->shared->nshadows = H5G_NSHADOWS;
- f->shared->shadow = H5MM_xcalloc (f->shared->nshadows,
- sizeof(struct H5G_hash_t*));
-
- /* Create a root symbol slot */
- f->shared->root_sym = H5G_ent_calloc ();
}
f->shared->nrefs++;
@@ -463,9 +455,7 @@ H5F_dest (H5F_t *f)
if (f) {
if (0 == --(f->shared->nrefs)) {
H5AC_dest (f);
- f->shared->root_sym = H5MM_xfree (f->shared->root_sym);
- f->shared->nshadows = 0;
- f->shared->shadow = H5MM_xfree (f->shared->shadow);
+ f->shared->root_ent = H5MM_xfree (f->shared->root_ent);
f->shared = H5MM_xfree (f->shared);
}
f->name = H5MM_xfree (f->name);
@@ -586,6 +576,7 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
size_t variable_size; /*variable part of boot block */
H5F_create_t *cp=NULL; /*file creation parameters */
haddr_t addr1, addr2; /*temporary address */
+ H5G_entry_t root_ent; /*root symbol table entry */
const char *s = name;
FUNC_ENTER (H5F_open, NULL);
@@ -887,10 +878,15 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
H5F_addr_decode (f, &p, &(f->shared->smallobj_addr));
H5F_addr_decode (f, &p, &(f->shared->freespace_addr));
H5F_addr_decode (f, &p, &(f->shared->hdf5_eof));
- if (H5G_ent_decode (f, &p, f->shared->root_sym)<0) {
+ if (H5G_ent_decode (f, &p, &root_ent)<0) {
HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
"can't read root symbol entry");
}
+ if (H5F_addr_defined (&(root_ent.header))) {
+ f->shared->root_ent = H5MM_xmalloc (sizeof(H5G_entry_t));
+ *(f->shared->root_ent) = root_ent;
+ }
+
/*
* The userdefined data is the area of the file before the base
@@ -1150,8 +1146,6 @@ hid_t H5Fopen(const char *filename, uintn flags, hid_t access_temp)
* Return: Success: SUCCEED
*
* Failure: FAIL
- * -2 if the there are open objects and
- * INVALIDATE was non-zero.
*
* Programmer: Robb Matzke
* matzke@llnl.gov
@@ -1165,7 +1159,6 @@ static herr_t
H5F_flush (H5F_t *f, hbool_t invalidate)
{
uint8 buf[2048], *p=buf;
- herr_t shadow_flush;
FUNC_ENTER (H5F_flush, FAIL);
@@ -1177,12 +1170,6 @@ H5F_flush (H5F_t *f, hbool_t invalidate)
*/
if (0==(H5F_ACC_WRITE & f->shared->flags)) HRETURN (SUCCEED);
- /*
- * Flush all open object info. If this fails just remember it and return
- * failure at the end. At least that way we get a consistent file.
- */
- shadow_flush = H5G_shadow_flush (f, invalidate);
-
/* flush (and invalidate) the entire cache */
if (H5AC_flush (f, NULL, 0, invalidate)<0) {
HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't flush cache");
@@ -1207,7 +1194,7 @@ H5F_flush (H5F_t *f, hbool_t invalidate)
H5F_addr_encode (f, &p, &(f->shared->smallobj_addr));
H5F_addr_encode (f, &p, &(f->shared->freespace_addr));
H5F_addr_encode (f, &p, &(f->shared->hdf5_eof));
- H5G_ent_encode (f, &p, f->shared->root_sym);
+ H5G_ent_encode (f, &p, f->shared->root_ent);
/* update file length if necessary */
if (!H5F_addr_defined (&(f->shared->hdf5_eof))) {
@@ -1226,11 +1213,6 @@ H5F_flush (H5F_t *f, hbool_t invalidate)
HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "low level flush failed");
}
- /* Did shadow flush fail above? */
- if (shadow_flush<0) {
- HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, -2, "object are still open");
- }
-
FUNC_LEAVE (SUCCEED);
}
@@ -1242,8 +1224,7 @@ H5F_flush (H5F_t *f, hbool_t invalidate)
*
* Return: Success: SUCCEED
*
- * Failure: FAIL, or -2 if the failure is due to objects
- * still being open.
+ * Failure: FAIL
*
* Programmer: Robb Matzke
* Tuesday, September 23, 1997
@@ -1255,27 +1236,24 @@ H5F_flush (H5F_t *f, hbool_t invalidate)
herr_t
H5F_close (H5F_t *f)
{
- herr_t ret_value = FAIL;
-
FUNC_ENTER (H5F_close, FAIL);
- if (-2==(ret_value=H5F_flush (f, TRUE))) {
- /*objects are still open, but don't fail yet*/
- } else if (ret_value<0) {
- HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL,
- "can't flush cache");
+ /* Close all current working groups */
+ while (H5G_pop (f)>=0) /*void*/;
+
+ /* Flush the boot block and caches */
+ if (H5F_flush (f, TRUE)<0) {
+ HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't flush cache");
}
+
+ /* Dump debugging info */
if (f->intent & H5F_ACC_DEBUG) H5AC_debug (f);
+ /* Close files and release resources */
H5F_low_close (f->shared->lf);
- H5F_dest (f);
-
- /* Did the H5F_flush() fail because of open objects? */
- if (ret_value<0) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, ret_value, "objects are open");
- }
+ f = H5F_dest (f);
- FUNC_LEAVE (ret_value);
+ FUNC_LEAVE (SUCCEED);
}
/*--------------------------------------------------------------------------
@@ -1537,8 +1515,14 @@ H5F_debug (H5F_t *f, const haddr_t *addr, FILE *stream, intn indent,
"Shared header version number:",
(unsigned)(f->shared->create_parms.sharedheader_ver));
- fprintf (stream, "%*sRoot symbol table entry:\n", indent, "");
- H5G_ent_debug (f, f->shared->root_sym, stream, indent+3, MAX(0, fwidth-3));
+ fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+ "Root symbol table entry:",
+ f->shared->root_ent ? "" : "(none)");
+ if (f->shared->root_ent) {
+ H5G_ent_debug (f, f->shared->root_ent, stream,
+ indent+3, MAX(0, fwidth-3));
+ }
+
FUNC_LEAVE (SUCCEED);
}
diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index 250c152..4e1abb1 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -331,9 +331,7 @@ typedef struct H5F_file_t {
#ifdef LATER
file_access_temp_t file_access_parms; /* File-access template */
#endif
- struct H5G_entry_t *root_sym; /* Root symbol table entry */
- uintn nshadows; /* Size of shadow hash table */
- struct H5G_hash_t **shadow; /* The shadow hash table */
+ struct H5G_entry_t *root_ent; /* Root symbol table entry */
} H5F_file_t;
/*
diff --git a/src/H5G.c b/src/H5G.c
index 25c5fc4..167de09 100644
--- a/src/H5G.c
+++ b/src/H5G.c
@@ -28,15 +28,13 @@
* Robb Matzke, 30 Aug 1997
* Added `Errors:' field to function prologues.
*
- * Robb Matzke, 18 Sep 1997
- * Added shadow entry support.
- *
*-------------------------------------------------------------------------
*/
#define H5G_PACKAGE /*suppress error message about including H5Gpkg.h*/
/* Packages needed by this file... */
#include <H5private.h>
+#include <H5Aprivate.h>
#include <H5Bprivate.h>
#include <H5Eprivate.h>
#include <H5Gpkg.h>
@@ -45,37 +43,38 @@
#include <H5Oprivate.h>
#define H5G_INIT_HEAP 8192
+#define H5G_RESERVED_ATOMS 0
#define PABLO_MASK H5G_mask
/* Interface initialization */
static hbool_t interface_initialize_g = FALSE;
-#define INTERFACE_INIT NULL
+#define INTERFACE_INIT H5G_init_interface
+static herr_t H5G_init_interface (void);
+static void H5G_term_interface (void);
+
+static H5G_entry_t *H5G_getcwg (H5F_t *f);
/*-------------------------------------------------------------------------
- * Function: H5Gnew
+ * Function: H5Gcreate
*
* Purpose: Creates a new group in FILE and gives it the specified
* NAME. Unless NAME begins with `/' it is relative to the
- * current working group.
+ * current working group. The group is opened for write access
+ * and it's object ID is returned.
*
* The optional SIZE_HINT specifies how much file space to
* reserve to store the names that will appear in this
- * group (an even number of characters, counting the null
- * terminator, is allocated for each name). If a non-positive
- * value is supplied for the SIZE_HINT then a default size is
- * chosen.
+ * group. If a non-positive value is supplied for the SIZE_HINT
+ * then a default size is chosen.
*
* See also: H5Gset(), H5Gpush(), H5Gpop()
*
* Errors:
- * ARGS BADTYPE Not a file atom.
- * ARGS BADVALUE No name given.
- * ATOM BADATOM Can't unatomize file.
- * SYM CANTINIT Can't close handle.
- * SYM CANTINIT Can't create group.
*
- * Return: Success: SUCCEED
+ * Return: Success: The object ID of a new, empty group open for
+ * writing. Call H5Gclose() when finished with
+ * the group.
*
* Failure: FAIL
*
@@ -86,47 +85,139 @@ static hbool_t interface_initialize_g = FALSE;
*
*-------------------------------------------------------------------------
*/
-herr_t
-H5Gnew (hid_t file, const char *name, size_t size_hint)
+hid_t
+H5Gcreate (hid_t file_id, const char *name, size_t size_hint)
{
- H5F_t *f=NULL;
- H5G_entry_t *grp_handle=NULL;
+ H5F_t *f = NULL;
+ H5G_t *grp;
+ hid_t ret_value = FAIL;
- FUNC_ENTER (H5Gnew, FAIL);
+ FUNC_ENTER (H5Gcreate, FAIL);
+ H5ECLEAR;
- /* Check/fix arguments */
+ /* Check arguments */
+ if (H5_FILE!=H5Aatom_group (file_id) ||
+ NULL==(f=H5Aatom_object (file_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
+ }
if (!name || !*name) {
HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given");
}
- if (H5_FILE!=H5Aatom_group (file)) {
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom");
+
+ /* Create the group */
+ if (NULL==(grp=H5G_create (f, name, size_hint))) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group");
}
- if (NULL==(f=H5Aatom_object (file))) {
- HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file");
+
+ if ((ret_value = H5Aregister_atom (H5_GROUP, grp))<0) {
+ H5G_close (grp);
+ HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
+ "unable to register group");
}
+
+ FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Gopen
+ *
+ * Purpose: Opens an existing group for modification. When finished,
+ * call H5Gclose() to close it and release resources.
+ *
+ * Errors:
+ *
+ * Return: Success: Object ID of the group.
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Wednesday, December 31, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Gopen (hid_t file_id, const char *name)
+{
+ hid_t ret_value = FAIL;
+ H5F_t *f = NULL;
+ H5G_t *grp = NULL;
- /* Create the group */
- if (NULL==(grp_handle=H5G_new (f, name, size_hint))) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
- "can't create group");
+ FUNC_ENTER (H5Gopen, FAIL);
+ H5ECLEAR;
+
+ /* Check args */
+ if (H5_FILE!=H5Aatom_group (file_id) ||
+ NULL==(f=H5Aatom_object (file_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
+ }
+ if (!name || !*name) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
}
- /* Close the group handle */
- if (H5G_close (f, grp_handle)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't close handle");
+ /* Open the group */
+ if (NULL==(grp=H5G_open (f, name))) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group");
}
- FUNC_LEAVE (SUCCEED);
+ /* Register an atom for the group */
+ if ((ret_value=H5Aregister_atom (H5_GROUP, grp))<0) {
+ H5G_close (grp);
+ HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
+ "unable to register group");
+ }
+
+ FUNC_LEAVE (ret_value);
}
+
+/*-------------------------------------------------------------------------
+ * Function: H5Gclose
+ *
+ * Purpose: Closes the specified group. The group ID will no longer be
+ * valid for accessing the group.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Wednesday, December 31, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Gclose (hid_t grp_id)
+{
+ H5G_t *grp = NULL;
+
+ FUNC_ENTER (H5Gclose, FAIL);
+ H5ECLEAR;
+
+ /* Check args */
+ if (H5_GROUP!=H5Aatom_group (grp_id) ||
+ NULL==(grp=H5Aatom_object (grp_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a group");
+ }
+
+ /* close it */
+ if (H5G_close (grp)<0) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to close group");
+ }
+
+ FUNC_LEAVE (SUCCEED);
+}
/*-------------------------------------------------------------------------
* Function: H5Gset
*
* Purpose: Sets the working group for file handle FILE to the
- * specified NAME. Unless NAME begins with a `/' it is
- * interpretted relative to the current working group.
+ * specified group.
*
* Each file handle maintains its own notion of the current
* working group. That is, if a single file is opened with
@@ -137,10 +228,6 @@ H5Gnew (hid_t file, const char *name, size_t size_hint)
* See also: H5Gpush(), H5Gpop()
*
* Errors:
- * ARGS BADTYPE Not a file atom.
- * ARGS BADVALUE No name given.
- * ATOM BADATOM Can't unatomize file.
- * SYM CANTINIT Can't change current working group.
*
* Return: Success: SUCCEED
*
@@ -154,32 +241,33 @@ H5Gnew (hid_t file, const char *name, size_t size_hint)
*-------------------------------------------------------------------------
*/
herr_t
-H5Gset (hid_t file, const char *name)
+H5Gset (hid_t file_id, hid_t grp_id)
{
H5F_t *f=NULL;
+ H5G_t *grp;
FUNC_ENTER (H5Gset, FAIL);
+ H5ECLEAR;
/* Check/fix arguments */
- if (!name || !*name) {
- HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given");
- }
- if (H5_FILE!=H5Aatom_group (file)) {
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom");
+ if (H5_FILE!=H5Aatom_group (file_id) ||
+ NULL==(f=H5Aatom_object (file_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
}
- if (NULL==(f=H5Aatom_object (file))) {
- HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file");
+ if (H5_GROUP!=H5Aatom_group (grp_id) ||
+ NULL==(grp=H5Aatom_object (grp_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a group");
}
- if (H5G_set (f, name)<0) {
+ /* Set the current working group */
+ if (H5G_set (f, grp)<0) {
HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
- "can't change current working group");
+ "unable to change current working group");
}
FUNC_LEAVE (SUCCEED);
}
-
/*-------------------------------------------------------------------------
* Function: H5Gpush
@@ -196,10 +284,6 @@ H5Gset (hid_t file, const char *name)
* See also: H5Gset(), H5Gpop()
*
* Errors:
- * ARGS BADTYPE Not a file atom.
- * ARGS BADVALUE No name given.
- * ATOM BADATOM Can't unatomize file.
- * SYM CANTINIT Can't change current working group.
*
* Return: Success: SUCCEED
*
@@ -213,24 +297,26 @@ H5Gset (hid_t file, const char *name)
*-------------------------------------------------------------------------
*/
herr_t
-H5Gpush (hid_t file, const char *name)
+H5Gpush (hid_t file_id, hid_t grp_id)
{
H5F_t *f=NULL;
+ H5G_t *grp;
FUNC_ENTER (H5Gpush, FAIL);
+ H5ECLEAR;
- /* Check/fix arguments */
- if (!name || !*name) {
- HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given");
+ /* Check arguments */
+ if (H5_FILE!=H5Aatom_group (file_id) ||
+ NULL==(f=H5Aatom_object (file_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
}
- if (H5_FILE!=H5Aatom_group (file)) {
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom");
+ if (H5_GROUP!=H5Aatom_group (grp_id) ||
+ NULL==(grp=H5Aatom_object (grp_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a group");
}
- if (NULL==(f=H5Aatom_object (file))) {
- HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file");
- }
-
- if (H5G_push (f, name)<0) {
+
+ /* Push group onto stack */
+ if (H5G_push (f, grp)<0) {
HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
"can't change current working group");
}
@@ -238,7 +324,6 @@ H5Gpush (hid_t file, const char *name)
FUNC_LEAVE (SUCCEED);
}
-
/*-------------------------------------------------------------------------
* Function: H5Gpop
@@ -255,9 +340,6 @@ H5Gpush (hid_t file, const char *name)
* See also: H5Gset(), H5Gpush()
*
* Errors:
- * ARGS BADTYPE Not a file atom.
- * ATOM BADATOM Can't unatomize file.
- * SYM CANTINIT Stack is empty.
*
* Return: Success: SUCCEED
*
@@ -273,20 +355,20 @@ H5Gpush (hid_t file, const char *name)
*-------------------------------------------------------------------------
*/
herr_t
-H5Gpop (hid_t file)
+H5Gpop (hid_t file_id)
{
H5F_t *f=NULL;
FUNC_ENTER (H5Gpop, FAIL);
-
- /* Check/fix arguments */
- if (H5_FILE!=H5Aatom_group (file)) {
- HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom");
- }
- if (NULL==(f=H5Aatom_object (file))) {
- HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file");
+ H5ECLEAR;
+
+ /* Check arguments */
+ if (H5_FILE!=H5Aatom_group (file_id) ||
+ NULL==(f=H5Aatom_object (file_id))) {
+ HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
}
+ /* pop */
if (H5G_pop (f)<0) {
HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
"stack is empty");
@@ -307,9 +389,59 @@ H5Gpop (hid_t file)
*/
+
+/*-------------------------------------------------------------------------
+ * Function: H5G_init_interface
+ *
+ * Purpose: Initializes the H5G interface.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Monday, January 5, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5G_init_interface (void)
+{
+ FUNC_ENTER (H5G_init_interface, FAIL);
+ /* Initialize the atom group for the group IDs */
+ if (H5Ainit_group (H5_GROUP, H5A_GROUPID_HASHSIZE, H5G_RESERVED_ATOMS,
+ (herr_t (*)(void*))H5G_close)<0 ||
+ H5_add_exit (H5G_term_interface)<0) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+ "unable to initialize interface");
+ }
+
+ FUNC_LEAVE (SUCCEED);
+}
-
+
+/*-------------------------------------------------------------------------
+ * Function: H5G_term_interface
+ *
+ * Purpose: Terminates the H5G interface
+ *
+ * Return: void
+ *
+ * Programmer: Robb Matzke
+ * Monday, January 5, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+H5G_term_interface (void)
+{
+ H5Adestroy_group (H5_GROUP);
+}
/*-------------------------------------------------------------------------
@@ -348,57 +480,58 @@ H5G_component (const char *name, size_t *size_p)
/*-------------------------------------------------------------------------
* Function: H5G_namei
*
- * Purpose: (Partially) translates a name to a symbol table entry.
- *
- * Given a name (absolute or relative) return the symbol table
- * entry for that name and for the group that contains the
- * base name. These entries (GRP_ENT and BASE_ENT) are returned
- * through memory passed into the function by the caller. Either
- * or both pointers may be null. Absolute names are looked up
- * relative to the root group of file F while relative
- * names are traversed beginning at the CWG argument.
- *
- * Consecutive slash characters are treated like single
- * slash characters. Trailing slashes are ignored. The
- * component `.' is recognized as the current group
- * during the traversal (initially CWG), but the component
- * `..' is not internally recognized (it is recognized if
- * such a name appears in the symbol table).
- *
- * If the name cannot be fully resolved, then REST will
- * point to the part of NAME where the traversal failed
- * (REST will always point to a relative name) and this
- * function will return null. GRP_ENT will be initialized with
- * information about the group (or other object) at which
- * the traversal failed. However, if the name can be fully
- * resolved, then REST points to the null terminator of NAME.
- *
- * As a special case, if the NAME is the name `/' (or
- * equivalent) then GRP_ENT is initialized to all zero
- * and an invalid header address and a pointer to the root
- * symbol table entry is returned.
- *
- * As a special case, if the NAME is the string `/foo' (or
- * equivalent) and the root symbol table entry points to a
- * non-group object with a name message with the value
- * `foo' then GRP_ENT is initialized to all zero (except for an
- * invalid header address) and a pointer to the root symbol
- * table entry is returned.
- *
+ * Purpose: Translates a name to a symbol table entry.
+ *
+ * If the specified name can be fully resolved, then this
+ * function returns the symbol table entry for the named object
+ * through the OBJ_ENT argument. The symbol table entry for the
+ * group containing the named object is returned through the
+ * GRP_ENT argument if it is non-null. However, if the name
+ * refers to the root object then the GRP_ENT will be
+ * initialized with an undefined object header address. The
+ * REST argument, if present, will point to the null terminator
+ * of NAME.
+ *
+ * If the specified name cannot be fully resolved, then OBJ_ENT
+ * is initialized with the undefined object header address. The
+ * REST argument will point into the NAME argument to the start
+ * of the component that could not be located. The GRP_ENT will
+ * contain the entry for the symbol table that was being
+ * searched at the time of the failure and will have an
+ * undefined object header address if the search failed at the
+ * root object. For instance, if NAME is `/foo/bar/baz' and the
+ * root directory exists and contains an entry for `foo', and
+ * foo is a group that contains an entry for baz, but baz is not
+ * a group, then the results will be that REST points to `baz',
+ * GRP_ENT has an undefined object header address, and GRP_ENT
+ * is the symbol table entry for `bar' in `/foo'.
+ *
+ * If a file contains more than one object, then `/' is the name
+ * of the root object which is a group. Otherwise, a file can
+ * consist of a single object, not necessarily a group, whose
+ * name is `/foo' where `foo' is the value of the name messsage
+ * in the object header. A file can also contain no objects in
+ * which case the function returns so REST points to the
+ * beginning of NAME and OBJ_ENT and GRP_ENT contain undefined
+ * header addresses.
+ *
+ * Components of a name are separated from one another by one or
+ * more slashes (/). Slashes at the end of a name are ignored.
+ * If the name begins with a slash then the search begins at the
+ * root object, otherwise it begins at the group CWG, otherwise
+ * it begins at the current working group of file F. The
+ * component `.' is a no-op, but `..' is not understood by this
+ * function (unless it appears as an entry in the symbol table).
+ *
* Errors:
- * SYM COMPLEN Component is too long.
- * SYM NOTFOUND Component not found.
- * SYM NOTFOUND No root group.
- * SYM NOTFOUND Root not found.
*
- * Return: Success: Pointer to a cached symbol table entry if the
- * name can be fully resolved. The pointer is
- * valid until one of the H5AC (cache) functions
- * is called.
+ * Return: Success: SUCCEED if name can be fully resolved. See
+ * above for values of REST, GRP_ENT, and
+ * OBJ_ENT.
*
- * Failure: Null if the name could not be fully resolved.
- * REST and GRP_ENT are initialized (possibly to
- * zero if the failure occurred soon enough).
+ * Failure: FAIL if the name could not be fully resolved.
+ * See above for values of REST, GRP_ENT, and
+ * OBJ_ENT.
*
* Programmer: Robb Matzke
* matzke@llnl.gov
@@ -408,46 +541,52 @@ H5G_component (const char *name, size_t *size_p)
*
*-------------------------------------------------------------------------
*/
-static H5G_entry_t *
+static herr_t
H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name,
- const char **rest/*out*/, H5G_entry_t *grp_ent/*out*/)
+ const char **rest/*out*/, H5G_entry_t *grp_ent/*out*/,
+ H5G_entry_t *obj_ent/*out*/)
{
- H5G_entry_t grp; /*entry for current group */
+ H5G_entry_t _grp_ent; /*entry for current group */
+ H5G_entry_t _obj_ent; /*entry found */
size_t nchars; /*component name length */
char comp[1024]; /*component name buffer */
hbool_t aside = FALSE; /*did we look at a name message?*/
- H5G_entry_t *ret_value=NULL; /*return value */
/* clear output args before FUNC_ENTER() in case it fails */
if (rest) *rest = name;
- if (grp_ent) {
- memset (grp_ent, 0, sizeof(H5G_entry_t));
- H5F_addr_undef (&(grp_ent->header));
- }
+ if (!grp_ent) grp_ent = &_grp_ent;
+ if (!obj_ent) obj_ent = &_obj_ent;
+ memset (grp_ent, 0, sizeof(H5G_entry_t));
+ H5F_addr_undef (&(grp_ent->header));
+ memset (obj_ent, 0, sizeof(H5G_entry_t));
+ H5F_addr_undef (&(obj_ent->header));
- FUNC_ENTER (H5G_namei, NULL);
+ FUNC_ENTER (H5G_namei, FAIL);
/* check args */
assert (f);
- assert (f->shared->root_sym);
assert (name && *name);
- assert (cwg || '/'==*name);
+ /* If the file contains no objects then return failure */
+ if (!f->shared->root_ent) {
+ HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "no root group");
+ }
+
/* starting point */
if ('/'==*name) {
- if (!H5F_addr_defined (&(f->shared->root_sym->header))) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
- "no root group");
- }
- ret_value = f->shared->root_sym;
- grp = *(f->shared->root_sym);
+ *obj_ent = *(f->shared->root_ent);
+ } else if (cwg) {
+ *obj_ent = *cwg;
+ } else if ((cwg=H5G_getcwg (f))) {
+ *obj_ent = *cwg;
} else {
- ret_value = cwg;
- grp = *cwg;
+ HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "no current working group");
}
+ assert (H5F_addr_defined (&(obj_ent->header)));
/* traverse the name */
while ((name=H5G_component (name, &nchars)) && *name) {
+ if (rest) *rest = name;
/*
* The special name `.' is a no-op.
@@ -457,67 +596,51 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name,
/*
* Advance to the next component of the name.
*/
- grp = *ret_value;
- ret_value = NULL;
- if (rest) *rest = name;
+ *grp_ent = *obj_ent;
+ HDmemset (obj_ent, 0, sizeof(H5G_entry_t));
+ H5F_addr_undef (&(obj_ent->header));
/*
* Copy the component name into a null-terminated buffer so
* we can pass it down to the other symbol table functions.
*/
if (nchars+1 > sizeof(comp)) {
- if (grp_ent) *grp_ent = grp;
- HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL, "component is too long");
+ HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, FAIL, "component is too long");
}
HDmemcpy (comp, name, nchars);
comp[nchars] = '\0';
- if (NULL==(ret_value=H5G_stab_find (f, NO_ADDR, &grp, comp))) {
+ if (H5G_stab_find (f, grp_ent, comp, obj_ent/*out*/)<0) {
/*
* Component was not found in the current symbol table, possibly
- * because GRP isn't a symbol table. If it is the root symbol then
- * see if it has the appropriate name field. The ASIDE variable
- * prevents us from saying `/foo/foo' where the root object has
- * the name `foo'.
+ * because GRP_ENT isn't a symbol table. If it is the root symbol
+ * then see if it has the appropriate name field. The ASIDE
+ * variable prevents us from saying `/foo/foo' where the root object
+ * has the name `foo'.
*/
H5O_name_t mesg={0};
if (!aside &&
- H5F_addr_defined (&(grp.header)) &&
- H5F_addr_defined (&(f->shared->root_sym->header)) &&
- H5F_addr_eq (&(grp.header), &(f->shared->root_sym->header)) &&
- H5O_read (f, &(grp.header), &grp, H5O_NAME, 0, &mesg) &&
+ H5F_addr_eq (&(grp_ent->header),
+ &(f->shared->root_ent->header)) &&
+ H5O_read (f, grp_ent, H5O_NAME, 0, &mesg) &&
!HDstrcmp (mesg.s, comp)) {
H5O_reset (H5O_NAME, &mesg);
- ret_value = f->shared->root_sym;
+ *obj_ent = *grp_ent;
+ HDmemset (grp_ent, 0, sizeof(H5G_entry_t));
+ H5F_addr_undef (&(grp_ent->header));
aside = TRUE;
} else {
H5O_reset (H5O_NAME, &mesg);
- if (grp_ent) *grp_ent = grp;
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "component not found");
+ HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "component not found");
}
}
/* next component */
name += nchars;
}
-
- /* output parameters */
if (rest) *rest = name; /*final null*/
- if (grp_ent) {
- if (H5F_addr_eq (&(ret_value->header), &(f->shared->root_sym->header))) {
- HDmemset (grp_ent, 0, sizeof(H5G_entry_t)); /*root has no parent*/
- H5F_addr_undef (&(grp_ent->header));
- } else {
- *grp_ent = grp;
- }
- }
- /* Perhaps the root object doesn't even exist! */
- if (!H5F_addr_defined (&(ret_value->header))) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "root not found");
- }
-
- FUNC_LEAVE (ret_value);
+ FUNC_LEAVE (SUCCEED);
}
@@ -532,16 +655,8 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name,
* is removed). If the root object doesn't have a name message
* then the name `Root Object' is used.
*
- * Warning: This function has a few subtleties. Be warned!
- *
* Errors:
- * SYM CANTINIT Can't open root object.
- * SYM CANTINIT Can't reinsert old root object.
- * SYM CANTINIT Cant create root.
- * SYM EXISTS Root group already exists.
- * SYM LINK Bad link count on old root object.
- * SYM LINK Cant create root.
- *
+ *
* Return: Success: SUCCEED
*
* Failure: FAIL. This function returns -2 if the
@@ -559,71 +674,50 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name,
static herr_t
H5G_mkroot (H5F_t *f, size_t size_hint)
{
- H5G_entry_t *handle=NULL; /*handle to open object */
herr_t ret_value=FAIL; /*return value */
H5O_name_t name={NULL}; /*object name */
H5O_stab_t stab; /*symbol table message */
- H5G_entry_t *ent_ptr=NULL; /*pointer to a symbol table entry*/
+ H5G_entry_t new_root; /*new root object */
const char *obj_name=NULL; /*name of old root object */
FUNC_ENTER (H5G_mkroot, FAIL);
+ /* check args */
+ assert (f);
+
/*
- * Make sure that the file descriptor has the latest info -- someone might
- * have the root object open.
- */
- H5G_shadow_sync (f->shared->root_sym);
-
- /*
- * If we already have a root object, then open it and get it's name. The
- * root object had better not already be a group. Once the old root
- * object is opened and we have a HANDLE, set the dirty bit on the handle.
- * This causes the handle data to be written back into f->root_sym by
- * H5G_close() if something goes wrong before the old root object is
- * re-inserted back into the group directed graph. We might leak file
- * memory, but at least we don't loose the original root object.
+ * If we already have a root object, then get it's name.
*/
- if (H5F_addr_defined (&(f->shared->root_sym->header))) {
- if (H5O_read (f, NO_ADDR, f->shared->root_sym, H5O_STAB, 0, &stab)) {
- HGOTO_ERROR (H5E_SYM, H5E_EXISTS, -2,
- "root group already exists");
- } else if (NULL==(handle=H5G_shadow_open (f, NULL,
- f->shared->root_sym))) {
- HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
- "can't open root object");
- } else if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &name)) {
+ if (f->shared->root_ent) {
+ if (H5O_read (f, f->shared->root_ent, H5O_STAB, 0, &stab)) {
+ HGOTO_ERROR (H5E_SYM, H5E_EXISTS, -2, "root group already exists");
+ } else if (NULL==H5O_read (f, f->shared->root_ent, H5O_NAME, 0, &name)) {
obj_name = "Root Object";
} else {
obj_name = name.s; /*don't reset message until the end!*/
}
- handle->dirty = TRUE;
}
/*
- * Create the new root group directly into the file descriptor. If
- * something goes wrong at this step, closing the `handle' will rewrite
- * info back into f->root_sym because we set the dirty bit.
+ * Create the new root group. Set the link count to 1.
*/
- if (H5G_stab_create (f, f->shared->root_sym, size_hint)<0) {
+ if (H5G_stab_create (f, size_hint, &new_root/*out*/)<0) {
HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "cant create root");
}
- if (1!=H5O_link (f, f->shared->root_sym, 1)) {
+ if (1!=H5O_link (f, &new_root, 1)) {
HGOTO_ERROR (H5E_SYM, H5E_LINK, FAIL,
"internal error (wrong link count)");
}
/*
* If there was a previous root object then insert it into the new root
- * symbol table with the specified name. Inserting the object will update
- * the handle to point to the new symbol table slot instead of f->root_sym.
+ * symbol table with the specified name. Then make the root object the
+ * new symbol table.
*/
- if (obj_name) {
- if (1!=H5O_link (f, handle, 0)) {
- HGOTO_ERROR (H5E_SYM, H5E_LINK, FAIL,
- "bad link count on old root object");
- }
- if (NULL==(ent_ptr=H5G_stab_insert (f, f->shared->root_sym, obj_name,
- handle))) {
+ if (f->shared->root_ent) {
+ assert (1==H5O_link (f, f->shared->root_ent, 0));
+
+ if (H5G_stab_insert (f, &new_root, obj_name, f->shared->root_ent)<0) {
HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
"can't reinsert old root object");
}
@@ -633,33 +727,31 @@ H5G_mkroot (H5F_t *f, size_t size_hint)
* a name message should ever appear is to give the root object a name,
* but the old root object is no longer the root object.
*/
- H5O_remove (f, NO_ADDR, handle, H5O_NAME, H5O_ALL);
+ H5O_remove (f, f->shared->root_ent, H5O_NAME, H5O_ALL);
H5ECLEAR; /*who really cares?*/
+
+ *(f->shared->root_ent) = new_root;
+
+ } else {
+ f->shared->root_ent = H5MM_xmalloc (sizeof(H5G_entry_t));
+ *(f->shared->root_ent) = new_root;
}
-
+
+ H5O_close (f, &new_root);
ret_value = SUCCEED;
done:
- /*
- * If the handle is closed before the H5G_stab_insert() call that
- * reinserts the root object into the group directed graph, then
- * H5G_close() will reset f->root_sym to point to the old root symbol and
- * the new root group (if it was created) will be unlinked from the
- * group directed graph (and memory leaked).
- */
- if (handle) H5G_close (f, handle);
H5O_reset (H5O_NAME, &name);
-
FUNC_LEAVE (ret_value);
}
/*-------------------------------------------------------------------------
- * Function: H5G_new
+ * Function: H5G_create
*
- * Purpose: Creates a new empty group with the specified name,
- * opening it as an object. The name is either an absolute name
- * or is relative to the current working group.
+ * Purpose: Creates a new empty group with the specified name. The name
+ * is either an absolute name or is relative to the current
+ * working group.
*
* A root group is created implicitly by this function
* when necessary. Calling this function with the name "/"
@@ -667,16 +759,10 @@ H5G_mkroot (H5F_t *f, size_t size_hint)
* failure.
*
* Errors:
- * SYM CANTINIT Can't create grp.
- * SYM CANTINIT Can't create root group.
- * SYM CANTINIT Can't insert.
- * SYM CANTINIT Can't open.
- * SYM COMPLEN Component is too long.
- * SYM EXISTS Already exists.
- * SYM NOTFOUND Missing component.
*
- * Return: Success: A handle to the open group. Please call
- * H5G_close() when you're done with it.
+ * Return: Success: A handle for the group. The group is opened
+ * and should eventually be close by calling
+ * H5G_close().
*
* Failure: NULL
*
@@ -688,57 +774,46 @@ H5G_mkroot (H5F_t *f, size_t size_hint)
*
*-------------------------------------------------------------------------
*/
-H5G_entry_t *
-H5G_new (H5F_t *f, const char *name, size_t size_hint)
+H5G_t *
+H5G_create (H5F_t *f, const char *name, size_t size_hint)
{
const char *rest=NULL; /*the base name */
- H5G_entry_t *cwg=NULL; /*current working group */
H5G_entry_t grp_ent; /*group containing new group */
- H5G_entry_t ent; /*new group entry */
- H5G_entry_t *ent_ptr=NULL; /*ptr to new group entry */
- H5G_entry_t *ret_value=NULL; /*handle return value */
char _comp[1024]; /*name component */
size_t nchars; /*number of characters in compon*/
herr_t status; /*function return status */
+ H5G_t *grp = NULL; /*new group */
- FUNC_ENTER (H5G_new, NULL);
+ FUNC_ENTER (H5G_create, NULL);
/* check args */
assert (f);
assert (name && *name);
-#ifndef LATER
- /* Get current working group */
- H5G_shadow_sync (f->shared->root_sym);
- cwg = f->shared->root_sym;
-#endif
- assert (cwg || '/'==*name);
/*
* Try to create the root group. Ignore the error if this function
* fails because the root group already exists.
*/
if ((status=H5G_mkroot (f, H5G_SIZE_HINT))<0 && -2!=status) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
- "can't create root group");
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't create root group");
}
H5ECLEAR;
/* lookup name */
- if (H5G_namei (f, cwg, name, &rest, &grp_ent)) {
+ if (0==H5G_namei (f, NULL, name, &rest, &grp_ent, NULL)) {
HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "already exists");
}
H5ECLEAR; /*it's OK that we didn't find it*/
+ assert (H5F_addr_defined (&(grp_ent.header)));
/* should be one null-terminated component left */
rest = H5G_component (rest, &nchars);
assert (rest && *rest);
if (rest[nchars]) {
if (H5G_component (rest+nchars, NULL)) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
- "missing component");
+ HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "missing component");
} else if (nchars+1 > sizeof _comp) {
- HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL,
- "component is too long");
+ HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL, "component is too long");
} else {
/* null terminate */
HDmemcpy (_comp, rest, nchars);
@@ -747,35 +822,154 @@ H5G_new (H5F_t *f, const char *name, size_t size_hint)
}
}
- /* create group */
- if (H5G_stab_create (f, &ent, size_hint)<0) {
+ /* create and open group */
+ grp = H5MM_xcalloc (1, sizeof(H5G_t));
+ grp->file = f;
+ if (H5G_stab_create (f, size_hint, &(grp->ent)/*out*/)<0) {
+ grp = H5MM_xfree (grp);
HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't create grp");
}
/* insert child name into parent */
- if (NULL==(ent_ptr=H5G_stab_insert (f, &grp_ent, rest, &ent))) {
+ if (H5G_stab_insert (f, &grp_ent, rest, &(grp->ent))<0) {
+ H5O_close (f, &(grp->ent));
+ grp = H5MM_xfree (grp);
HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't insert");
}
- /* open the group */
- if (NULL==(ret_value=H5G_shadow_open (f, &grp_ent, ent_ptr))) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't open");
+ grp->nref = 1;
+ FUNC_LEAVE (grp);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5G_open
+ *
+ * Purpose: Opens an existing group. The group should eventually be
+ * closed by calling H5G_close().
+ *
+ * Return: Success: Ptr to a new group.
+ *
+ * Failure: NULL
+ *
+ * Programmer: Robb Matzke
+ * Monday, January 5, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5G_t *
+H5G_open (H5F_t *f, const char *name)
+{
+ H5G_t *grp = NULL;
+ H5G_t *ret_value = NULL;
+
+ FUNC_ENTER (H5G_open, NULL);
+
+ /* Check args */
+ assert (f);
+ assert (name && *name);
+
+ /* Open the group */
+ grp = H5MM_xcalloc (1, sizeof(H5G_t));
+ if (H5G_find (f, name, NULL, &(grp->ent))<0) {
+ HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "group not found");
+ }
+ if (H5O_open (f, &(grp->ent))<0) {
+ HGOTO_ERROR (H5E_SYM, H5E_CANTOPENOBJ, NULL, "unable to open group");
+ }
+ grp->file = f;
+ grp->nref = 1;
+ ret_value = grp;
+
+ done:
+ if (!ret_value && grp) {
+ H5MM_xfree (grp);
}
FUNC_LEAVE (ret_value);
}
+
+/*-------------------------------------------------------------------------
+ * Function: H5G_reopen
+ *
+ * Purpose: Reopens a group by incrementing the open count.
+ *
+ * Return: Success: The GRP argument.
+ *
+ * Failure: NULL
+ *
+ * Programmer: Robb Matzke
+ * Monday, January 5, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5G_t *
+H5G_reopen (H5G_t *grp)
+{
+ FUNC_ENTER (H5G_reopen, NULL);
+
+ assert (grp);
+ assert (grp->nref>0);
+
+ grp->nref++;
+
+ FUNC_LEAVE (grp);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5G_close
+ *
+ * Purpose: Closes the specified group.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Monday, January 5, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_close (H5G_t *grp)
+{
+ FUNC_ENTER (H5G_close, FAIL);
+
+ /* Check args */
+ assert (grp);
+ assert (grp->nref>0);
+
+ if (1==grp->nref) {
+ if (H5O_close (grp->file, &(grp->ent))<0) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to close");
+ }
+ }
+ --grp->nref;
+
+ FUNC_LEAVE (SUCCEED);
+}
/*-------------------------------------------------------------------------
* Function: H5G_set
*
- * Purpose: Sets the current working group to be the specified name.
+ * Purpose: Sets the current working group to be the specified group.
* This affects only the top item on the group stack for the
* specified file as accessed through this file handle. If the
* file is opened multiple times, then the current working group
* for this file handle is the only one that is changed.
*
+ * Note: The group is re-opened and held open until it is removed from
+ * the current working group stack.
+ *
* Errors:
* SYM CWG Can't open group.
* SYM CWG Couldn't close previous c.w.g.
@@ -793,19 +987,20 @@ H5G_new (H5F_t *f, const char *name, size_t size_hint)
*-------------------------------------------------------------------------
*/
herr_t
-H5G_set (H5F_t *f, const char *name)
+H5G_set (H5F_t *f, H5G_t *grp)
{
- H5G_entry_t *handle=NULL;
- H5O_stab_t stab_mesg;
- herr_t ret_value=FAIL;
-
FUNC_ENTER (H5G_set, FAIL);
- if (NULL==(handle=H5G_open (f, name))) {
- HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "can't open group");
- }
- if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &stab_mesg)) {
- HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "not a group");
+ /* check args */
+ assert (f);
+ assert (grp);
+
+ /*
+ * Are the group and file compatible?
+ */
+ if (grp->file->shared!=f->shared) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+ "group is not compatible with file");
}
/*
@@ -814,36 +1009,27 @@ H5G_set (H5F_t *f, const char *name)
*/
if (!f->cwg_stack) {
f->cwg_stack = H5MM_xcalloc (1, sizeof(H5G_cwgstk_t));
- f->cwg_stack->handle = handle;
- } else {
- if (H5G_close (f, f->cwg_stack->handle)<0) {
- HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL,
- "couldn't close previous c.w.g.");
- }
- f->cwg_stack->handle = handle;
+ } else if (H5G_close (f->cwg_stack->grp)<0) {
+ HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL, "couldn't close previous c.w.g.");
}
- ret_value = SUCCEED;
+ f->cwg_stack->grp = H5G_reopen (grp);
- done:
- if (ret_value<0 && handle) {
- H5G_close (f, handle);
- }
-
- FUNC_LEAVE (ret_value);
+ FUNC_LEAVE (SUCCEED);
}
-
/*-------------------------------------------------------------------------
* Function: H5G_getcwg
*
- * Purpose: Returns a handle for the current working group. If there
- * is no current working group then a pointer to the root
- * symbol is returned but that object is not opened (and it
- * might not even be a group).
+ * Purpose: Returns a ptr to the symbol table entry for the current
+ * working group. If there is no current working group then a
+ * pointer to the root symbol is returned. If there is no root
+ * symbol then the null pointer is returned.
*
- * Return: Success: Ptr to open group handle with exceptions
- * noted above.
+ * Return: Success: Ptr to the current working group or root
+ * object. The pointer is valid only until the
+ * root object changes or the current working
+ * group changes.
*
* Failure: NULL
*
@@ -857,26 +1043,29 @@ H5G_set (H5F_t *f, const char *name)
static H5G_entry_t *
H5G_getcwg (H5F_t *f)
{
- H5G_entry_t *handle=NULL;
+ H5G_entry_t *ret_value=NULL;
FUNC_ENTER (H5G_getcwg, NULL);
+
+ /* check args */
+ assert (f);
- if (f->cwg_stack && f->cwg_stack->handle) {
- handle = f->cwg_stack->handle;
+ /* return a pointer directly into the stack */
+ if (f->cwg_stack && f->cwg_stack->grp) {
+ ret_value = &(f->cwg_stack->grp->ent);
} else {
- H5G_shadow_sync (f->shared->root_sym);
- handle = f->shared->root_sym;
+ ret_value = f->shared->root_ent;
}
- FUNC_LEAVE (handle);
+ FUNC_LEAVE (ret_value);
}
-
/*-------------------------------------------------------------------------
* Function: H5G_push
*
- * Purpose: Pushes a new current working group onto the stack.
+ * Purpose: Pushes a new current working group onto the stack. The GRP
+ * is reopened and held open until it is removed from the stack.
*
* Errors:
* SYM CWG Can't open group.
@@ -894,35 +1083,31 @@ H5G_getcwg (H5F_t *f)
*-------------------------------------------------------------------------
*/
herr_t
-H5G_push (H5F_t *f, const char *name)
+H5G_push (H5F_t *f, H5G_t *grp)
{
- H5G_entry_t *handle=NULL;
H5G_cwgstk_t *stack=NULL;
- H5O_stab_t stab_mesg;
- herr_t ret_value = FAIL;
FUNC_ENTER (H5G_push, FAIL);
- if (NULL==(handle=H5G_open (f, name))) {
- HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "can't open group");
- }
- if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &stab_mesg)) {
- HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "not a group");
- }
+ /* check args */
+ assert (f);
+ assert (grp);
/*
+ * Are the group and file compatible?
+ */
+ if (grp->file->shared!=f->shared) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+ "group is not compatible with file");
+ }
+
+ /*
* Push a new entry onto the stack.
*/
stack = H5MM_xcalloc (1, sizeof(H5G_cwgstk_t));
- stack->handle = handle;
+ stack->grp = H5G_reopen (grp);
stack->next = f->cwg_stack;
f->cwg_stack = stack;
- ret_value = SUCCEED;
-
- done:
- if (ret_value<0 && handle) {
- H5G_close (f, handle);
- }
FUNC_LEAVE (SUCCEED);
}
@@ -955,13 +1140,16 @@ H5G_pop (H5F_t *f)
FUNC_ENTER (H5G_pop, FAIL);
+ /* check args */
+ assert (f);
+
if ((stack=f->cwg_stack)) {
- if (H5G_close (f, stack->handle)<0) {
+ if (H5G_close (stack->grp)<0) {
HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL,
"can't close current working group");
}
f->cwg_stack = stack->next;
- stack->handle = NULL;
+ stack->grp = NULL;
H5MM_xfree (stack);
} else {
HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL, "stack is empty");
@@ -972,30 +1160,13 @@ H5G_pop (H5F_t *f)
/*-------------------------------------------------------------------------
- * Function: H5G_create
+ * Function: H5G_insert
*
- * Purpose: Creates a new empty object header, gives it a name, opens
- * the object for modification, and returns a handle to the
- * object. The initial size of the object header can be
- * supplied with the OHDR_HINT argument.
+ * Purpose: Inserts a symbol table entry into the group graph.
*
* Errors:
- * SYM CANTINIT Bad link count.
- * SYM CANTINIT Can't create header.
- * SYM CANTINIT Can't create root group.
- * SYM CANTINIT Can't insert.
- * SYM CANTINIT Can't open object.
- * SYM CANTINIT Cannot add/change name message.
- * SYM CANTINIT Create the object header.
- * SYM COMPLEN Component is too long.
- * SYM EXISTS Already exists.
- * SYM EXISTS Root exists.
- * SYM LINK Bad link count.
- * SYM LINK Link inc failure.
- * SYM NOTFOUND Component not found.
- *
- * Return: Success: A handle for the object. Be sure to
- * eventually close it.
+ *
+ * Return: Success: SUCCEED
*
* Failure: FAIL
*
@@ -1006,35 +1177,28 @@ H5G_pop (H5F_t *f)
*
*-------------------------------------------------------------------------
*/
-H5G_entry_t *
-H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
+herr_t
+H5G_insert (H5F_t *f, const char *name, H5G_entry_t *ent)
{
- H5G_entry_t ent; /*entry data for the new object */
- H5G_entry_t *ent_ptr; /*ptr into symbol node for entry*/
- H5G_entry_t *cwg=NULL; /*ptr to c.w.g. handle */
const char *rest = NULL; /*part of name not existing yet */
H5G_entry_t grp; /*entry for group to contain obj*/
- H5G_entry_t *ret_value=NULL; /*the object handle */
size_t nchars; /*number of characters in name */
char _comp[1024]; /*name component */
+ hbool_t update_grp;
+ herr_t status;
- FUNC_ENTER (H5G_create, NULL);
+ FUNC_ENTER (H5G_insert, FAIL);
/* Check args. */
assert (f);
assert (name && *name);
- HDmemset (&ent, 0, sizeof(H5G_entry_t));
-
- /*
- * Get the current working group.
- */
- cwg = H5G_getcwg (f);
+ assert (ent);
/*
* Look up the name -- it shouldn't exist yet.
*/
- if (H5G_namei (f, cwg, name, &rest, &grp)) {
- HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "already exists");
+ if (H5G_namei (f, NULL, name, &rest, &grp, NULL)>=0) {
+ HRETURN_ERROR (H5E_SYM, H5E_EXISTS, FAIL, "already exists");
}
H5ECLEAR; /*it's OK that we didn't find it*/
rest = H5G_component (rest, &nchars);
@@ -1045,22 +1209,16 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
* doesn't have a name or we shouldn't interfere with the name
* it already has as a message.
*/
- if (H5F_addr_defined (&(f->shared->root_sym->header))) {
- HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "root exists");
+ if (f->shared->root_ent) {
+ HRETURN_ERROR (H5E_SYM, H5E_EXISTS, FAIL, "root exists");
}
- if (H5O_create (f, 0, ohdr_hint, &(ent.header)/*out*/)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
- "can't create header");
+ if (1!=H5O_link (f, ent, 1)) {
+ HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, "bad link count");
}
- if (1!=H5O_link (f, &ent, 1)) {
- HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL, "bad link count");
- }
- *(f->shared->root_sym) = ent;
- if (NULL==(ret_value=H5G_shadow_open (f, NULL, f->shared->root_sym))) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
- "can't open root object");
- }
- HRETURN (ret_value);
+ f->shared->root_ent = H5MM_xmalloc (sizeof(H5G_entry_t));
+ ent->name_off = 0;
+ *(f->shared->root_ent) = *ent;
+ HRETURN (SUCCEED);
}
/*
@@ -1069,11 +1227,9 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
*/
if (rest[nchars]) {
if (H5G_component (rest+nchars, NULL)) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
- "component not found");
+ HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "component not found");
} else if (nchars+1 > sizeof _comp) {
- HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL,
- "component is too long");
+ HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, FAIL, "component is too long");
} else {
/* null terminate */
HDmemcpy (_comp, rest, nchars);
@@ -1082,166 +1238,50 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
}
}
- /*
- * Create the object header.
- */
- if (H5O_create (f, 0, ohdr_hint, &(ent.header)/*out*/)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
- "can't create object header");
- }
-
-
- if (!H5F_addr_defined (&(f->shared->root_sym->header))) {
+ if (!f->shared->root_ent) {
/*
* This will be the only object in the file. Insert it as the root
* object and add a name messaage to the object header (or modify
- * the first one we find). Although the header exists we can guarantee
- * that it isn't open since it has no name.
+ * the first one we find).
*/
H5O_name_t name_mesg;
name_mesg.s = rest;
- if (H5O_modify (f, NO_ADDR, &ent, H5O_NAME, 0, &name_mesg)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
+ if (H5O_modify (f, ent, H5O_NAME, 0, &name_mesg)<0) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
"cannot add/change name message");
}
- if (1!=H5O_link (f, &ent, 1)) {
- HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL, "bad link count");
- }
- *(f->shared->root_sym) = ent;
- if (NULL==(ret_value=H5G_shadow_open (f, &grp, f->shared->root_sym))) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
- "can't open root object");
+ if (1!=H5O_link (f, ent, 1)) {
+ HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, "bad link count");
}
- HRETURN (ret_value);
- } else {
- /*
- * Make sure the root group exists. Ignore the failure if it's
- * because the group already exists.
- */
- hbool_t update_grp = H5F_addr_eq (&(grp.header),
- &(f->shared->root_sym->header));
- herr_t status = H5G_mkroot (f, H5G_SIZE_HINT);
- if (status<0 && -2!=status) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
- "can't create root group");
- }
- H5ECLEAR;
- if (update_grp) grp = *(f->shared->root_sym);
+ f->shared->root_ent = H5MM_xmalloc (sizeof(H5G_entry_t));
+ *(f->shared->root_ent) = *ent;
+ HRETURN (SUCCEED);
}
-
+
/*
- * This is the normal case. The object is just being inserted as a normal
- * entry into a symbol table.
+ * Make sure the root group exists. Ignore the failure if it's
+ * because the group already exists.
*/
- if (H5O_link (f, &ent, 1)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL, "link inc failure");
- }
- if (NULL==(ent_ptr=H5G_stab_insert (f, &grp, rest, &ent))) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't insert");
- }
- if (NULL==(ret_value=H5G_shadow_open (f, &grp, ent_ptr))) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't open object");
+ update_grp = H5F_addr_eq (&(grp.header),
+ &(f->shared->root_ent->header));
+ if ((status=H5G_mkroot (f, H5G_SIZE_HINT))<0 && -2!=status) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't create root group");
}
- FUNC_LEAVE (ret_value);
-}
+ H5ECLEAR;
+ if (update_grp) grp = *(f->shared->root_ent);
-
-/*-------------------------------------------------------------------------
- * Function: H5G_open
- *
- * Purpose: Opens an object. That is, it prepares the object for
- * modification by returning a handle to the object
- * symbol table entry. Opening an object twice with the
- * same name (or more precisely, through the same final
- * symbol table entry) will return pointers to the same
- * H5G_entry_t struct. But opening an object through
- * different final H5G_entry_t structs (which implies
- * different names) returns pointers to different
- * structs. The structs that are returned should be
- * released by calling H5G_close().
- *
- * Errors:
- * SYM BADVALUE Check args.
- * SYM CANTOPENOBJ Can't open obj.
- * SYM NOTFOUND Object not found.
- *
- * Return: Success: Ptr to a handle for the object.
- *
- * Failure: NULL
- *
- * Programmer: Robb Matzke
- * Wednesday, September 17, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-H5G_entry_t *
-H5G_open (H5F_t *f, const char *name)
-{
- H5G_entry_t *ent=NULL;
- H5G_entry_t *ret_value=NULL;
- H5G_entry_t grp;
- H5G_entry_t *cwg=NULL;
- FUNC_ENTER (H5G_open, NULL);
-
- /* check args */
- assert (f);
- if (!name || !*name) {
- HRETURN_ERROR (H5E_SYM, H5E_BADVALUE, NULL, "no name");
- }
-
- /* Get CWG */
- cwg = H5G_getcwg (f);
- assert (cwg || '/'==*name);
-
- if (!H5F_addr_defined (&(f->shared->root_sym->header))) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "object not found");
- }
- if (NULL==(ent=H5G_namei (f, cwg, name, NULL, &grp))) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "object not found");
+ /*
+ * This is the normal case. The object is just being inserted as a normal
+ * entry into a symbol table.
+ */
+ if (H5O_link (f, ent, 1)<0) {
+ HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, "link inc failure");
}
- if (NULL==(ret_value=H5G_shadow_open (f, &grp, ent))) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTOPENOBJ, NULL, "can't open obj");
+ if (H5G_stab_insert (f, &grp, rest, ent)<0) {
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't insert");
}
- FUNC_LEAVE (ret_value);
-}
-
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_close
- *
- * Purpose: Closes an object that was open for modification.
- *
- * Errors:
- * SYM CANTFLUSH Can't close object.
- *
- * Return: Success: SUCCEED
- *
- * Failure: FAIL
- *
- * Programmer: Robb Matzke
- * Thursday, September 18, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_close (H5F_t *f, H5G_entry_t *ent)
-{
- FUNC_ENTER (H5G_close, FAIL);
-
- assert (f);
-
- if (ent && H5G_shadow_close (f, ent)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL,
- "can't close object");
- }
-
FUNC_LEAVE (SUCCEED);
}
@@ -1254,25 +1294,19 @@ H5G_close (H5F_t *f, H5G_entry_t *ent)
* to the current working group. On successful return,
* GRP_ENT (if non-null) will be initialized with the symbol
* table information for the group in which the object
- * appears (or all zero if the returned object is the root
- * object) and ENT will be initialized with the symbol table
- * entry for the object (ENT is optional when the caller is
- * interested only in the existence of the object).
+ * appears (it will have an undefined object header address if
+ * the object is the root object) and OBJ_ENT will be
+ * initialized with the symbol table entry for the object
+ * (OBJ_ENT is optional when the caller is interested only in
+ * the existence of the object).
*
- * This function will fail if the root object is
- * requested and there is none.
+ * This function will fail if the root object is requested and
+ * there is none.
*
* Errors:
- * SYM NOTFOUND Object not found.
*
- * Return: Success: SUCCEED with GRP_ENT and ENT initialized. ENT
- * is intended for immediate read-only access.
- * If the object that ENT refers to is open
- * through the ENT entry (see H5G_open()) then
- * the returned ENT will contain the latest
- * information. However, subsequent changes to
- * the symbol table entry will not be reflected
- * in ENT since it is a copy of the symbol table.
+ * Return: Success: SUCCEED, see above for values of GRP_ENT and
+ * OBJ_ENT.
*
* Failure: FAIL
*
@@ -1286,28 +1320,17 @@ H5G_close (H5F_t *f, H5G_entry_t *ent)
*/
herr_t
H5G_find (H5F_t *f, const char *name,
- H5G_entry_t *grp_ent/*out*/, H5G_entry_t *ent/*out*/)
+ H5G_entry_t *grp_ent/*out*/, H5G_entry_t *obj_ent/*out*/)
{
- H5G_entry_t *ent_p = NULL;
- H5G_entry_t *cwg = NULL;
-
FUNC_ENTER (H5G_find, FAIL);
/* check args */
assert (f);
assert (name && *name);
- cwg = H5G_getcwg (f);
- assert (cwg || '/'==*name);
- if (!H5F_addr_defined (&(f->shared->root_sym->header))) {
+ if (H5G_namei (f, NULL, name, NULL, grp_ent, obj_ent)<0) {
HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "object not found");
}
- if (NULL==(ent_p=H5G_namei (f, cwg, name, NULL, grp_ent))) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "object not found");
- }
-
- if (ent) *ent = *ent_p;
FUNC_LEAVE (SUCCEED);
}
-
diff --git a/src/H5Gent.c b/src/H5Gent.c
index b8510f7..cc33d4c 100644
--- a/src/H5Gent.c
+++ b/src/H5Gent.c
@@ -364,35 +364,42 @@ H5G_ent_encode (H5F_t *f, uint8 **pp, H5G_entry_t *ent)
/* check arguments */
assert (f);
assert (pp);
- assert (ent);
-
- /* encode header */
- H5F_encode_length (f, *pp, ent->name_off);
- H5F_addr_encode (f, pp, &(ent->header));
- UINT32ENCODE (*pp, ent->type);
-
- /* encode scratch-pad */
- switch (ent->type) {
- case H5G_NOTHING_CACHED:
- break;
-
- case H5G_CACHED_SDSPACE:
- assert (5*4 <= H5G_SIZEOF_SCRATCH);
- UINT32ENCODE (*pp, ent->cache.sdspace.ndim);
- UINT32ENCODE (*pp, ent->cache.sdspace.dim[0]);
- UINT32ENCODE (*pp, ent->cache.sdspace.dim[1]);
- UINT32ENCODE (*pp, ent->cache.sdspace.dim[2]);
- UINT32ENCODE (*pp, ent->cache.sdspace.dim[3]);
- break;
- case H5G_CACHED_STAB:
- assert (2*H5F_SIZEOF_ADDR (f) <= H5G_SIZEOF_SCRATCH);
- H5F_addr_encode (f, pp, &(ent->cache.stab.btree_addr));
- H5F_addr_encode (f, pp, &(ent->cache.stab.heap_addr));
- break;
-
- default:
- HDabort();
+ if (ent) {
+ /* encode header */
+ H5F_encode_length (f, *pp, ent->name_off);
+ H5F_addr_encode (f, pp, &(ent->header));
+ UINT32ENCODE (*pp, ent->type);
+
+ /* encode scratch-pad */
+ switch (ent->type) {
+ case H5G_NOTHING_CACHED:
+ break;
+
+ case H5G_CACHED_SDSPACE:
+ assert (5*4 <= H5G_SIZEOF_SCRATCH);
+ UINT32ENCODE (*pp, ent->cache.sdspace.ndim);
+ UINT32ENCODE (*pp, ent->cache.sdspace.dim[0]);
+ UINT32ENCODE (*pp, ent->cache.sdspace.dim[1]);
+ UINT32ENCODE (*pp, ent->cache.sdspace.dim[2]);
+ UINT32ENCODE (*pp, ent->cache.sdspace.dim[3]);
+ break;
+
+ case H5G_CACHED_STAB:
+ assert (2*H5F_SIZEOF_ADDR (f) <= H5G_SIZEOF_SCRATCH);
+ H5F_addr_encode (f, pp, &(ent->cache.stab.btree_addr));
+ H5F_addr_encode (f, pp, &(ent->cache.stab.heap_addr));
+ break;
+
+ default:
+ HDabort();
+ }
+ } else {
+ haddr_t undef;
+ H5F_encode_length (f, *pp, 0);
+ H5F_addr_undef (&undef);
+ H5F_addr_encode (f, pp, &undef);
+ UINT32ENCODE (*pp, H5G_NOTHING_CACHED);
}
/* fill with zero */
@@ -443,11 +450,6 @@ H5G_ent_debug (H5F_t *f, H5G_entry_t *ent, FILE *stream, intn indent,
fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
"Dirty:",
ent->dirty ? "Yes" : "No");
- fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
- "Has a shadow:",
- H5G_shadow_p (ent)?"This is a shadow!" :
- (ent->shadow ? "Yes" : "No"));
-
fprintf (stream, "%*s%-*s ", indent, "", fwidth,
"Symbol type:");
switch (ent->type) {
diff --git a/src/H5Gnode.c b/src/H5Gnode.c
index c4349a5..f124d3e 100644
--- a/src/H5Gnode.c
+++ b/src/H5Gnode.c
@@ -15,12 +15,6 @@
*
* Modifications:
*
- * Robb Matzke, 5 Aug 1997
- * Added calls to H5E.
- *
- * Robb Matzke, 18 Sep 1997
- * Added shadow entries.
- *
*-------------------------------------------------------------------------
*/
#define H5G_PACKAGE /*suppress error message about including H5Gpkg.h*/
@@ -216,10 +210,10 @@ H5G_node_size (H5F_t *f)
/*-------------------------------------------------------------------------
* Function: H5G_node_create
*
- * Purpose: Creates a new empty symbol table. This function is called
- * by the B-tree insert function for an empty tree. It is
- * also called internally to split a symbol node with
- * LT_KEY and RT_KEY null pointers.
+ * Purpose: Creates a new empty symbol table node. This function is
+ * called by the B-tree insert function for an empty tree. It
+ * is also called internally to split a symbol node with LT_KEY
+ * and RT_KEY null pointers.
*
* Return: Success: SUCCEED. The address of symbol table node is
* returned through the ADDR argument.
@@ -285,10 +279,7 @@ H5G_node_create (H5F_t *f, H5B_ins_t op,
/*-------------------------------------------------------------------------
* Function: H5G_node_flush
*
- * Purpose: Flush a symbol table node to disk. If any entries have dirty
- * shadows, the shadow value is copied into the entry before the
- * entry is flushed. The association between shadows and
- * entries is broken.
+ * Purpose: Flush a symbol table node to disk.
*
* Return: Success: SUCCEED
*
@@ -321,15 +312,9 @@ H5G_node_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr,
assert (sym);
/*
- * Synchronize all entries with their corresponding shadow if they have
- * one. Also look for dirty entries and set the node dirty flag.
+ * Look for dirty entries and set the node dirty flag.
*/
for (i=0; i<sym->nsyms; i++) {
- if (H5G_shadow_sync (sym->entry+i)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL,
- "unable to synchronize symbol table node with open "
- "objects");
- }
if (sym->entry[i].dirty) sym->dirty = TRUE;
}
@@ -366,13 +351,9 @@ H5G_node_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr,
/*
* Destroy the symbol node? This might happen if the node is being
- * preempted from the cache. We should also dissociate the shadow
- * from the entry.
+ * preempted from the cache.
*/
if (destroy) {
- for (i=0; i<sym->nsyms; i++) {
- H5G_shadow_dissociate (sym->entry+i);
- }
sym->entry = H5MM_xfree (sym->entry);
H5MM_xfree (sym);
}
@@ -384,8 +365,7 @@ H5G_node_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr,
/*-------------------------------------------------------------------------
* Function: H5G_node_load
*
- * Purpose: Loads a symbol table from the file and associates shadows
- * with their entries.
+ * Purpose: Loads a symbol table node from the file.
*
* Return: Success: Ptr to the new table.
*
@@ -407,7 +387,6 @@ H5G_node_load (H5F_t *f, const haddr_t *addr, const void *_udata1,
size_t size = 0;
uint8 *buf = NULL;
const uint8 *p = NULL;
- const H5G_ac_ud1_t *ac_udata = (const H5G_ac_ud1_t*)_udata1;
H5G_node_t *ret_value = NULL; /*for error handling*/
FUNC_ENTER (H5G_node_load, NULL);
@@ -417,7 +396,7 @@ H5G_node_load (H5F_t *f, const haddr_t *addr, const void *_udata1,
*/
assert (f);
assert (addr && H5F_addr_defined (addr));
- assert (ac_udata);
+ assert (!_udata1);
assert (NULL==_udata2);
/*
@@ -459,18 +438,6 @@ H5G_node_load (H5F_t *f, const haddr_t *addr, const void *_udata1,
}
buf = H5MM_xfree (buf);
- /*
- * shadows. If we are running this under the debugger, then the grp_addr
- * field of ac_udata might be undefined. If that's the case, then we
- * don't try to associate any shadows with this symbol table node.
- */
- if (H5F_addr_defined (&(ac_udata->grp_addr)) &&
- H5G_shadow_assoc_node (f, sym, ac_udata)<0) {
- HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL,
- "unable to associate symbol table node with open "
- "objects");
- }
-
ret_value = sym;
@@ -609,8 +576,8 @@ H5G_node_cmp3 (H5F_t *f, void *_lt_key, void *_udata, void *_rt_key)
* entry field. Otherwise the entry is copied from the
* UDATA entry field to the symbol table.
*
- * Return: Success: SUCCEED if found and data returned through the
- * UDATA pointer.
+ * Return: Success: SUCCEED if found and data returned through
+ * the UDATA pointer.
*
* Failure: FAIL if not found.
*
@@ -627,7 +594,6 @@ H5G_node_found (H5F_t *f, const haddr_t *addr, const void *_lt_key,
void *_udata, const void *_rt_key)
{
H5G_bt_ud1_t *bt_udata = (H5G_bt_ud1_t *)_udata;
- H5G_ac_ud1_t ac_udata;
H5G_node_t *sn = NULL;
intn lt=0, idx=0, rt, cmp=1;
const char *s;
@@ -642,13 +608,11 @@ H5G_node_found (H5F_t *f, const haddr_t *addr, const void *_lt_key,
assert (addr && H5F_addr_defined (addr));
assert (bt_udata);
- ac_udata.grp_addr = bt_udata->grp_addr;
- ac_udata.heap_addr = bt_udata->heap_addr;
/*
* Load the symbol table node for exclusive access.
*/
- if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, addr, &ac_udata, NULL))) {
+ if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, addr, NULL, NULL))) {
HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL,
"unable to protect symbol table node");
}
@@ -680,10 +644,7 @@ H5G_node_found (H5F_t *f, const haddr_t *addr, const void *_lt_key,
* The caller is querying the symbol entry. Return just a pointer to
* the entry. The pointer is valid until the next call to H5AC.
*/
- H5G_shadow_sync (sn->entry+idx);
- bt_udata->entry_ptr = sn->entry+idx;
- bt_udata->node_addr = *addr;
- bt_udata->node_ptr = sn;
+ bt_udata->ent = sn->entry[idx];
break;
default:
@@ -694,16 +655,9 @@ H5G_node_found (H5F_t *f, const haddr_t *addr, const void *_lt_key,
ret_value = SUCCEED;
done:
- /*
- * Don't unprotect the symbol table entry if we're returning success since
- * this might invalidate the bt_udata->entry_ptr and bt_udata->node_ptr
- * pointers. Instead, we unprotect it in H5G_stab_find().
- */
- if (ret_value<0) {
- if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_PROTECT, FAIL,
- "unable to release symbol table node");
- }
+ if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
+ HRETURN_ERROR (H5E_SYM, H5E_PROTECT, FAIL,
+ "unable to release symbol table node");
}
FUNC_LEAVE (ret_value);
@@ -744,10 +698,6 @@ done:
*
* Modifications:
*
- * Robb Matzke, 18 Sep 1997
- * If the shadow pointer is non-null then the shadow is updated to point
- * to the new entry.
- *
*-------------------------------------------------------------------------
*/
static H5B_ins_t
@@ -761,15 +711,12 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
H5G_node_key_t *rt_key = (H5G_node_key_t *)_rt_key;
H5G_bt_ud1_t *bt_udata = (H5G_bt_ud1_t *)_udata;
- H5G_ac_ud1_t ac_udata;
H5G_node_t *sn=NULL, *snrt=NULL;
size_t offset; /*offset of name in heap*/
const char *s;
intn idx=-1, cmp=1;
intn lt=0, rt; /*binary search cntrs */
- intn i;
H5B_ins_t ret_value = H5B_INS_ERROR;
- H5G_shadow_t *shadow = NULL;
H5G_node_t *insert_into=NULL; /*node that gets new entry*/
haddr_t insert_addr; /*address of that node */
@@ -785,17 +732,10 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
assert (bt_udata);
assert (new_node);
- /* Init return value */
- H5F_addr_undef (&(bt_udata->node_addr));
- bt_udata->node_ptr = NULL;
- bt_udata->entry_ptr = NULL;
-
/*
* Load the symbol node.
*/
- ac_udata.grp_addr = bt_udata->grp_addr;
- ac_udata.heap_addr = bt_udata->heap_addr;
- if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, addr, &ac_udata, NULL))) {
+ if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, addr, NULL, NULL))) {
HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR,
"unable to protect symbol table node");
}
@@ -831,7 +771,7 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
*/
offset = H5H_insert (f, &(bt_udata->heap_addr), HDstrlen(bt_udata->name)+1,
bt_udata->name);
- bt_udata->entry.name_off = offset;
+ bt_udata->ent.name_off = offset;
if (offset<=0) {
HGOTO_ERROR (H5E_SYM, H5E_CANTINSERT, H5B_INS_ERROR,
"unable to insert symbol name into heap");
@@ -851,7 +791,7 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, H5B_INS_ERROR,
"unable to split symbol table node");
}
- if (NULL==(snrt=H5AC_find (f, H5AC_SNODE, new_node, &ac_udata, NULL))) {
+ if (NULL==(snrt=H5AC_find (f, H5AC_SNODE, new_node, NULL, NULL))) {
HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR,
"unable to split symbol table node");
}
@@ -860,13 +800,6 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
snrt->nsyms = H5G_NODE_K(f);
snrt->dirty = TRUE;
- /* Right shadows */
- for (i=0; i<H5G_NODE_K(f); i++) {
- if ((shadow = snrt->entry[i].shadow)) {
- shadow->main = snrt->entry + i;
- }
- }
-
/* The left node */
HDmemset (sn->entry + H5G_NODE_K(f), 0,
H5G_NODE_K(f) * sizeof(H5G_entry_t));
@@ -899,55 +832,18 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
}
}
- /* Adjust shadows */
- for (i=idx; i<insert_into->nsyms; i++) {
- if (insert_into->entry[i].shadow) {
- insert_into->entry[i].shadow->main = insert_into->entry + i + 1;
- }
- }
- if (bt_udata->entry.shadow) {
- H5G_shadow_move (f, bt_udata->entry.shadow,
- bt_udata->name,
- insert_into->entry + idx,
- &(bt_udata->grp_addr));
- }
-
/* Move entries */
HDmemmove (insert_into->entry + idx + 1,
insert_into->entry + idx,
(insert_into->nsyms-idx) * sizeof(H5G_entry_t));
- insert_into->entry[idx] = bt_udata->entry;
- insert_into->entry[idx].name_off = offset;
+ insert_into->entry[idx] = bt_udata->ent;
insert_into->entry[idx].dirty = TRUE;
insert_into->nsyms += 1;
- /* Update udata return values */
- bt_udata->node_addr = insert_addr;
- bt_udata->node_ptr = insert_into;
- bt_udata->entry_ptr = insert_into->entry + idx;
-
done:
- if (ret_value<0) {
- /* failing... */
- if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_PROTECT, H5B_INS_ERROR,
- "unable to release symbol table node");
- }
- } else if (insert_into!=sn) {
- /* unprotect the first node and protect the return value */
- if (H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_PROTECT, H5B_INS_ERROR,
- "unable to release symbol table node");
- }
- if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, &insert_addr, &ac_udata,
- NULL))) {
- HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR,
- "unable to protect symbol table node");
- }
- bt_udata->node_ptr = sn;
- bt_udata->entry_ptr = sn->entry + idx;
- } else {
- /* keep the node protected until we get back to H5G_stab_insert() */
+ if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
+ HRETURN_ERROR (H5E_SYM, H5E_PROTECT, H5B_INS_ERROR,
+ "unable to release symbol table node");
}
FUNC_LEAVE (ret_value);
@@ -980,7 +876,6 @@ H5G_node_list (H5F_t *f, const haddr_t *addr, void *_udata)
intn i;
const char *s;
herr_t ret_value = FAIL;
- H5G_ac_ud1_t ac_udata;
FUNC_ENTER (H5G_node_list, FAIL);
@@ -991,9 +886,7 @@ H5G_node_list (H5F_t *f, const haddr_t *addr, void *_udata)
assert (addr && H5F_addr_defined (addr));
assert (bt_udata);
- ac_udata.grp_addr = bt_udata->grp_addr;
- ac_udata.heap_addr = bt_udata->heap_addr;
- if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, addr, &ac_udata, NULL))) {
+ if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, addr, NULL, NULL))) {
HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL,
"unable to protect symbol table node");
}
@@ -1013,7 +906,6 @@ H5G_node_list (H5F_t *f, const haddr_t *addr, void *_udata)
*/
if (bt_udata->entry) {
for (i=0; i<sn->nsyms && bt_udata->nsyms+i<bt_udata->maxentries; i++) {
- H5G_shadow_sync (sn->entry+i);
bt_udata->entry[bt_udata->nsyms+i] = sn->entry[i];
}
}
@@ -1065,11 +957,10 @@ herr_t
H5G_node_debug (H5F_t *f, const haddr_t *addr, FILE *stream, intn indent,
intn fwidth, const haddr_t *heap)
{
- int i, acc;
+ int i;
H5G_node_t *sn = NULL;
herr_t status;
const char *s;
- H5G_ac_ud1_t ac_udata;
FUNC_ENTER (H5G_node_debug, FAIL);
@@ -1082,23 +973,12 @@ H5G_node_debug (H5F_t *f, const haddr_t *addr, FILE *stream, intn indent,
assert (indent>=0);
assert (fwidth>=0);
- /*
- * We have absolutely no idea where the object header for the symbol table
- * to which this node belongs is located. In fact, if the file is corrupt,
- * there may not even be an object header for that symbol table. So we
- * supply UNDEF as the group address which causes no open objects to be
- * associated with the node. For that reason, we flush this node from the
- * cache when we're done so if some later caller knows the header address
- * they'll be able to access the open objects.
- */
- H5F_addr_undef (&(ac_udata.grp_addr));
- ac_udata.heap_addr = *heap;
/*
* If we couldn't load the symbol table node, then try loading the
* B-tree node.
*/
- if (NULL==(sn=H5AC_protect(f, H5AC_SNODE, addr, &ac_udata, NULL))) {
+ if (NULL==(sn=H5AC_protect(f, H5AC_SNODE, addr, NULL, NULL))) {
H5ECLEAR; /*discard that error*/
status = H5B_debug (f, addr, stream, indent, fwidth, H5B_SNODE, NULL);
if (status<0) {
@@ -1116,11 +996,6 @@ H5G_node_debug (H5F_t *f, const haddr_t *addr, FILE *stream, intn indent,
fprintf (stream, "%*s%-*s %d of %d\n", indent, "", fwidth,
"Number of Symbols:",
sn->nsyms, 2*H5G_NODE_K(f));
- for (i=acc=0; i<sn->nsyms; i++) {
- if (sn->entry[i].shadow) acc++;
- }
- fprintf (stream, "%*s%-*s %d\n", indent, "", fwidth,
- "Shadows:", acc);
indent += 3;
@@ -1134,13 +1009,9 @@ H5G_node_debug (H5F_t *f, const haddr_t *addr, FILE *stream, intn indent,
s);
}
H5G_ent_debug (f, sn->entry+i, stream, indent, fwidth);
- fprintf (stream, "%*s%-*s %s\n", indent+3, "", MAX (0, fwidth-3),
- "Shadow:",
- sn->entry[i].shadow ? "Yes":"No");
}
H5AC_unprotect (f, H5AC_SNODE, addr, sn);
- H5AC_flush (f, H5AC_SNODE, addr, TRUE); /*see note above*/
FUNC_LEAVE (SUCCEED);
}
diff --git a/src/H5Gpkg.h b/src/H5Gpkg.h
index 473c3c5..5b8bbe5 100644
--- a/src/H5Gpkg.h
+++ b/src/H5Gpkg.h
@@ -26,21 +26,6 @@
#define H5G_DEFAULT_ROOT_SIZE 32
/*
- * A symbol table entry. The two important fields are `name_off' and
- * `header'. The remaining fields are used for caching information that
- * also appears in the object header to which this symbol table entry
- * points.
- */
-struct H5G_entry_t {
- hbool_t dirty; /*entry out-of-date? */
- size_t name_off; /*offset of name within name heap */
- haddr_t header; /*file address of object header */
- H5G_type_t type; /*type of information cached */
- H5G_cache_t cache; /*cached data from object header */
- H5G_shadow_t *shadow; /*optional ptr to the shadow */
-};
-
-/*
* A symbol table node is a collection of symbol table entries. It can
* be thought of as the lowest level of the B-link tree that points to
* a collection of symbol table entries that belong to a specific symbol
@@ -53,23 +38,6 @@ typedef struct H5G_node_t {
} H5G_node_t;
/*
- * A shadow is a copy of a symbol table entry which corresponds to an
- * `open' object. Shadows are necessary because normal symbol table
- * entries can be preempted from the main cache. The `shadow' field
- * of the `entry' points to the beginning of the shadow just like the
- * shadow field from symbol table entries in H5G_node_t.
- */
-struct H5G_shadow_t {
- char *name; /*name for this entry */
- haddr_t grp_addr; /*hdr addr for group containing shadow */
- uintn nrefs; /*reference counter */
- H5G_entry_t entry; /*local copy of symbol table entry */
- H5G_entry_t *main; /*main entry in stab node if cached */
- struct H5G_shadow_t *next; /*next shadow for same symbol table */
- struct H5G_shadow_t *prev; /*previous shadow for same symbol table */
-};
-
-/*
* Each key field of the B-link tree that points to symbol table
* nodes consists of this structure...
*/
@@ -78,13 +46,23 @@ typedef struct H5G_node_key_t {
} H5G_node_key_t;
/*
+ * A group handle passed around through layers of the library within and
+ * above the H5G layer.
+ */
+struct H5G_t {
+ H5F_t *file; /*file containing group */
+ int nref; /*open reference count */
+ H5G_entry_t ent; /*info about the group */
+};
+
+/*
* Each file has a stack of open groups with the latest entry on the
* stack the current working group. If the stack is empty then the
* current working group is the root object.
*/
typedef struct H5G_cwgstk_t {
- H5G_entry_t *handle; /*a handle to an open group */
- struct H5G_cwgstk_t *next; /*next item (earlier) on stack */
+ H5G_t *grp; /*a handle to an open group */
+ struct H5G_cwgstk_t *next; /*next item (earlier) on stack */
} H5G_cwgstk_t;
/*
@@ -106,16 +84,10 @@ typedef struct H5G_bt_ud1_t {
/* downward */
H5G_oper_t operation; /*what operation to perform */
const char *name; /*points to temporary memory */
- haddr_t grp_addr; /*symbol table header address */
haddr_t heap_addr; /*symbol table heap address */
- /* downward for INSERT */
- H5G_entry_t entry; /*entry to insert into table */
-
- /* upward for FIND and INSERT */
- haddr_t node_addr; /*address of node for this entry */
- H5G_node_t *node_ptr; /*ptr to the node containing the entry */
- H5G_entry_t *entry_ptr; /*ptr into cached symbol table node */
+ /* downward for INSERT, upward for FIND */
+ H5G_entry_t ent; /*entry to insert into table */
} H5G_bt_ud1_t;
@@ -129,7 +101,6 @@ typedef struct H5G_bt_ud2_t {
H5G_entry_t *entry; /*array of entries, alloc'd by caller */
char **name; /*array of string ptrs, allocd by caller*/
intn maxentries; /*size of the ADDR and NAME arrays */
- haddr_t grp_addr; /*symbol table header address */
haddr_t heap_addr; /*heap address */
/* upward */
@@ -142,14 +113,6 @@ typedef struct H5G_bt_ud2_t {
*/
extern H5B_class_t H5B_SNODE[1];
-/*
- * This struct passes information through the H5AC layer.
- */
-typedef struct H5G_ac_ud1_t {
- haddr_t heap_addr;
- haddr_t grp_addr;
-} H5G_ac_ud1_t;
-
/* The cache subclass */
extern const H5AC_class_t H5AC_SNODE[1];
@@ -158,31 +121,15 @@ extern const H5AC_class_t H5AC_SNODE[1];
* functions that understand names are exported to the rest of
* the library and appear in H5Gprivate.h.
*/
-herr_t H5G_stab_create (H5F_t *f, H5G_entry_t *self, size_t init);
-H5G_entry_t *H5G_stab_find (H5F_t *f, const haddr_t *addr, H5G_entry_t *self,
- const char *name);
-H5G_entry_t *H5G_stab_insert (H5F_t *f, H5G_entry_t *self,
- const char *name, H5G_entry_t *ent);
+herr_t H5G_stab_create (H5F_t *f, size_t size_hint, H5G_entry_t *ent/*out*/);
+herr_t H5G_stab_find (H5F_t *f, H5G_entry_t *grp_ent, const char *name,
+ H5G_entry_t *obj_ent/*out*/);
+herr_t H5G_stab_insert (H5F_t *f, H5G_entry_t *grp_ent, const char *name,
+ H5G_entry_t *obj_ent);
intn H5G_stab_list (H5F_t *f, H5G_entry_t *self, intn maxentries,
char *names[], H5G_entry_t entries[]);
/*
- * Functions that understand shadow entries.
- */
-herr_t H5G_shadow_sync (H5G_entry_t *ent);
-H5G_entry_t *H5G_shadow_open (H5F_t *f, H5G_entry_t *grp,
- H5G_entry_t *ent);
-herr_t H5G_shadow_close (H5F_t *f, H5G_entry_t *ent);
-hbool_t H5G_shadow_p (H5G_entry_t *ent);
-herr_t H5G_shadow_dissociate (H5G_entry_t *ent);
-herr_t H5G_shadow_assoc_node (H5F_t *f, H5G_node_t *sym,
- const H5G_ac_ud1_t *ac_udata);
-H5G_shadow_t *H5G_shadow_list (H5F_t *f, const haddr_t *stab_header_addr);
-herr_t H5G_shadow_move (H5F_t *f, H5G_shadow_t *shadow,
- const char *new_name, H5G_entry_t *new_entry,
- const haddr_t *grp_addr);
-
-/*
* Functions that understand symbol table entries.
*/
herr_t H5G_ent_decode_vec (H5F_t *f, const uint8 **pp, H5G_entry_t *ent,
diff --git a/src/H5Gprivate.h b/src/H5Gprivate.h
index 6b8989e..0ee5e17 100644
--- a/src/H5Gprivate.h
+++ b/src/H5Gprivate.h
@@ -24,11 +24,7 @@
#include <H5Fprivate.h>
/*
- * FEATURE: If this macro is defined then H5G_shadow_check() is occassionally
- * (actually, quite often) called to check the consistency of the
- * shadow table. If there's something wrong with the table then
- * abort() is called. Shadow table checking is a rather expensive
- * operation.
+ * Define this to enable debugging.
*/
#ifdef NDEBUG
# undef H5G_DEBUG
@@ -37,7 +33,6 @@
#define H5G_NODE_MAGIC "SNOD" /*symbol table node magic number */
#define H5G_NODE_SIZEOF_MAGIC 4 /*sizeof symbol node magic number */
#define H5G_NO_CHANGE (-1) /*see H5G_ent_modified() */
-#define H5G_NSHADOWS 10331 /*default size of shadow hash table */
/*
* The disk size for a symbol table entry...
@@ -78,24 +73,33 @@ typedef union H5G_cache_t {
} H5G_cache_t;
/*
- * An H5G_shadow_t is the struct used to describe object headers that
- * are currently open for modification. It's contents is not
- * important outside H5G.
+ * A symbol table entry. The two important fields are `name_off' and
+ * `header'. The remaining fields are used for caching information that
+ * also appears in the object header to which this symbol table entry
+ * points.
*/
-typedef struct H5G_shadow_t H5G_shadow_t;
-typedef struct H5G_entry_t H5G_entry_t;
+typedef struct H5G_entry_t {
+ hbool_t dirty; /*entry out-of-date? */
+ size_t name_off; /*offset of name within name heap */
+ haddr_t header; /*file address of object header */
+ H5G_type_t type; /*type of information cached */
+ H5G_cache_t cache; /*cached data from object header */
+} H5G_entry_t;
+
+typedef struct H5G_t H5G_t;
/*
* Library prototypes... These are the ones that other packages routinely
* call.
*/
-H5G_entry_t *H5G_new (H5F_t *f, const char *name, size_t size_hint);
-herr_t H5G_set (H5F_t *f, const char *name);
-herr_t H5G_push (H5F_t *f, const char *name);
+H5G_t *H5G_create (H5F_t *f, const char *name, size_t size_hint);
+H5G_t *H5G_open (H5F_t *f, const char *name);
+H5G_t *H5G_reopen (H5G_t *grp);
+herr_t H5G_close (H5G_t *grp);
+herr_t H5G_set (H5F_t *f, H5G_t *grp);
+herr_t H5G_push (H5F_t *f, H5G_t *grp);
herr_t H5G_pop (H5F_t *f);
-H5G_entry_t *H5G_create (H5F_t *f, const char *name, size_t ohdr_hint);
-H5G_entry_t *H5G_open (H5F_t *f, const char *name);
-herr_t H5G_close (H5F_t *f, H5G_entry_t *ent);
+herr_t H5G_insert (H5F_t *f, const char *name, H5G_entry_t *ent);
herr_t H5G_find (H5F_t *f, const char *name, H5G_entry_t *grp_ent,
H5G_entry_t *ent);
herr_t H5G_ent_encode (H5F_t *f, uint8 **pp, H5G_entry_t *ent);
@@ -108,11 +112,6 @@ herr_t H5G_node_debug (H5F_t *f, const haddr_t *addr, FILE *stream,
intn indent, intn fwidth, const haddr_t *heap);
/*
- * These functions operate on shadow entries.
- */
-herr_t H5G_shadow_flush (H5F_t *f, hbool_t invalidate);
-
-/*
* These functions operate on symbol table entries. They're used primarily
* in the H5O package where header messages are cached in symbol table
* entries. The subclasses of H5O probably don't need them though.
diff --git a/src/H5Gpublic.h b/src/H5Gpublic.h
index e546e6d..2d6b55c 100644
--- a/src/H5Gpublic.h
+++ b/src/H5Gpublic.h
@@ -27,9 +27,12 @@
extern "C" {
#endif
-herr_t H5Gnew (hid_t file, const char *name, size_t size_hint);
-herr_t H5Gset (hid_t file, const char *name);
-herr_t H5Gpush (hid_t file, const char *name);
+hid_t H5Gcreate (hid_t file_id, const char *name, size_t size_hint);
+hid_t H5Gopen (hid_t file_id, const char *name);
+herr_t H5Gclose (hid_t grp_id);
+
+herr_t H5Gset (hid_t file, hid_t grp_id);
+herr_t H5Gpush (hid_t file, hid_t grp_id);
herr_t H5Gpop (hid_t file);
#ifdef __cplusplus
diff --git a/src/H5Gshad.c b/src/H5Gshad.c
deleted file mode 100644
index 861f7e5..0000000
--- a/src/H5Gshad.c
+++ /dev/null
@@ -1,810 +0,0 @@
-/*
- * Copyright (C) 1997 National Center for Supercomputing Applications.
- * All rights reserved.
- *
- * Programmer: Robb Matzke <matzke@llnl.gov>
- * Thursday, September 18, 1997
- */
-#define H5G_PACKAGE /*suppress error message about including H5Gpkg.h*/
-
-#include <H5private.h> /*library */
-#include <H5Eprivate.h> /*error handling */
-#include <H5Gpkg.h> /*symbol tables */
-#include <H5Hprivate.h> /*heap functions */
-#include <H5MMprivate.h> /*memory management */
-#include <H5Oprivate.h> /*object header messages */
-
-#define PABLO_MASK H5G_shadow_mask
-
-/* Interface initialization */
-static hbool_t interface_initialize_g = FALSE;
-#define INTERFACE_INIT NULL
-
-typedef struct H5G_hash_t {
- haddr_t grp_addr;
- H5G_shadow_t *head;
- struct H5G_hash_t *next;
- struct H5G_hash_t *prev;
-} H5G_hash_t;
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_check
- *
- * Purpose: Checks the shadow data structures for validity. This is a
- * debugging function only--it aborts on failure!
- *
- * Return: void
- *
- * Programmer: Robb Matzke
- * Sunday, September 21, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-#ifdef H5G_DEBUG
-static void
-H5G_shadow_check (H5F_t *f)
-{
- H5G_hash_t *hash=NULL;
- H5G_shadow_t *shadow=NULL, *prev_shadow=NULL;
- uintn idx;
- hbool_t shadow_error=FALSE;
- uintn nerrors=0;
- static int ncalls=0;
-
- if (0==ncalls++) {
- fprintf (stderr, "HDF5-DIAG: debugging group shadows (expensive)\n");
- }
-
- for (idx=0; idx<f->shared->nshadows; idx++) {
- for (hash=f->shared->shadow[idx]; hash; hash=hash->next) {
- for (shadow=hash->head,prev_shadow=NULL;
- shadow;
- shadow=shadow->next) {
- shadow_error = FALSE;
-
- /* Each shadow has a name and the names are in order */
- if (!shadow->name) {
- fprintf (stderr, "name=NULL, ");
- shadow_error = TRUE;
- }
- if (prev_shadow && strcmp (prev_shadow->name, shadow->name)>=0) {
- fprintf (stderr, "names not sorted, ");
- shadow_error = TRUE;
- }
-
- /*
- * Valid group addresses. The root (which is hashed to entry
- * zero) always has an undefined group address.
- */
- if (idx==0 &&
- !H5F_addr_defined (&(shadow->grp_addr)) &&
- !H5F_addr_defined (&(hash->grp_addr))) {
- /*
- * The shadow for the root object always has an undefined
- * group address.
- */
-
- } else if (!H5F_addr_defined (&(shadow->grp_addr)) ||
- !H5F_addr_defined (&(hash->grp_addr))) {
- /*
- * Non-root objects must have defined group addresses.
- */
- fprintf (stderr, "grp_addr=");
- H5F_addr_print (stderr, &(shadow->grp_addr));
- fprintf (stderr, ", hash_addr=");
- H5F_addr_print (stderr, &(hash->grp_addr));
- fprintf (stderr, ", ");
- shadow_error = TRUE;
-
- } else if (H5F_addr_ne (&(shadow->grp_addr), &(hash->grp_addr))) {
- /*
- * Something's wrong with the data structure. The hash
- * address should always be the same as the shadow group
- * address.
- */
- fprintf (stderr, "grp_addr=");
- H5F_addr_print (stderr, &(shadow->grp_addr));
- fprintf (stderr, " (should be ");
- H5F_addr_print (stderr, &(hash->grp_addr));
- fprintf (stderr, "), ");
- shadow_error = TRUE;
- }
-
- /* Linked to symbol table entry */
- if (shadow->main && shadow!=shadow->main->shadow) {
- fprintf (stderr, "entry linkage problem, ");
- shadow_error = TRUE;
- }
-
- /* Shadow linked list is consistent */
- if (shadow->prev && prev_shadow!=shadow->prev) {
- fprintf (stderr, "shadow linked list problem, ");
- shadow_error = TRUE;
- }
- prev_shadow = shadow;
-
- /* If an error occurred then print other info */
- if (shadow_error) {
- fprintf (stderr, "idx=%u, shadow=0x%08lx, grp_addr=",
- idx, (unsigned long)shadow);
- H5F_addr_print (stderr, &(shadow->grp_addr));
- fprintf (stderr, "\n");
- nerrors++;
- }
- }
- }
- }
- if (nerrors) {
- fprintf (stderr, "Error in H5G_shadow_check, call %d\n", ncalls);
- abort ();
- }
-}
-#endif
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_p
- *
- * Purpose: Determines if ENT is a shadow or a real symbol table entry.
- *
- * Return: Success: Non-zero if ENT is a shadow; zero otherwise.
- *
- * Failure: FALSE
- *
- * Programmer: Robb Matzke
- * Thursday, September 18, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-hbool_t
-H5G_shadow_p (H5G_entry_t *ent)
-{
- H5G_shadow_t tmp;
- size_t delta = (char*)&(tmp.entry) - (char*)&tmp;
- hbool_t ret_value = FALSE;
-
- FUNC_ENTER (H5G_shadow_p, FALSE);
-
- if (!ent || !ent->shadow) return FALSE;
- ret_value = ((char*)ent - (char*)(ent->shadow) == delta);
-
- FUNC_LEAVE (ret_value);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_dissociate
- *
- * Purpose: Removes the association between a shadow and its entry or an
- * entry and its shadow. The ENT argument can be a shadow or a
- * cached entry.
- *
- * Return: Success: SUCCEED
- *
- * Failure: FAIL
- *
- * Programmer: Robb Matzke
- * Thursday, September 18, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_shadow_dissociate (H5G_entry_t *ent)
-{
- FUNC_ENTER (H5G_shadow_dissociate, FAIL);
-
- if (H5G_shadow_p (ent)) {
- if (ent->shadow->main) {
- ent->shadow->main->shadow = NULL;
- ent->shadow->main = NULL;
- }
- } else if (ent && ent->shadow) {
- ent->shadow->main = NULL;
- ent->shadow = NULL;
- }
-
- FUNC_LEAVE (SUCCEED);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_sync
- *
- * Purpose: Synchronizes a shadow with an entry by copying the
- * shadow contents to the entry if the shadow is dirty,
- * and then clearing the shadow dirty bit. You may call this
- * function with either a shadow or a real entry.
- *
- * If ENT is a shadow, then the shadow is synchronized only if
- * the entry is currently cached.
- *
- * Return: Success: SUCCEED
- *
- * Failure: FAIL
- *
- * Programmer: Robb Matzke
- * Thursday, September 18, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_shadow_sync (H5G_entry_t *ent)
-{
- H5G_shadow_t *shadow = NULL;
- FUNC_ENTER (H5G_shadow_sync, FAIL);
-
- /*
- * If the caller supplied us with a shadow instead of the main entry, then
- * adjust the arguments.
- */
- if (H5G_shadow_p (ent)) {
- shadow = ent->shadow;
- ent = shadow->main;
- } else {
- shadow = ent->shadow;
- }
-
- if (shadow && shadow->entry.dirty) {
- if (!ent) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTCACHED, FAIL,
- "main entry is not cached");
- }
- *ent = shadow->entry;
- shadow->entry.dirty = FALSE;
- }
- FUNC_LEAVE (SUCCEED);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_list
- *
- * Purpose: Returns a doubly linked list of shadows for the symbol
- * table whose header address is GRP_ADDR.
- *
- * Return: Success: Ptr shadow list or null.
- *
- * Failure: NULL
- *
- * Programmer: Robb Matzke
- * Wednesday, September 17, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-H5G_shadow_t *
-H5G_shadow_list (H5F_t *f, const haddr_t *grp_addr)
-{
- uintn idx = H5F_addr_hash (grp_addr, f->shared->nshadows);
- H5G_hash_t *bucket = NULL;
-
- FUNC_ENTER (H5G_shadows, NULL);
-
- for (bucket=f->shared->shadow[idx]; bucket; bucket=bucket->next) {
- if (0==idx &&
- !H5F_addr_defined (&(bucket->grp_addr)) &&
- !H5F_addr_defined (grp_addr)) {
- HRETURN (bucket->head);/*shadow list for root object*/
- } else if (H5F_addr_eq (&(bucket->grp_addr), grp_addr)) {
- HRETURN (bucket->head);/*shadow list for other objects*/
- }
- }
- FUNC_LEAVE (NULL);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_assoc_node
- *
- * Purpose: Given a new symbol table node and a symbol table header
- * address, associate entries in that node with their shadow if
- * they have one.
- *
- * SYM must be an uncached or protected symbol table node.
- *
- * Return: Success: SUCCEED
- *
- * Failure: FAIL, if an error occurs then none of the
- * entries are associated with shadows.
- *
- * Programmer: Robb Matzke
- * Wednesday, September 17, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_shadow_assoc_node (H5F_t *f, H5G_node_t *sym, const H5G_ac_ud1_t *ac_udata)
-{
- H5G_shadow_t *shadow = NULL;
- const char *s = NULL;
- intn i = 0;
- haddr_t heap_addr;
-
- FUNC_ENTER (H5G_shadow_assoc_node, FAIL);
-
- /* Check arguments */
- assert (f); /* The file */
- assert (sym); /* The symbol table node */
- assert (ac_udata); /* The symbol table header info */
-
-#ifdef H5G_DEBUG
- H5G_shadow_check (f);
-#endif
-
- if ((shadow=H5G_shadow_list (f, &(ac_udata->grp_addr)))) {
- heap_addr = ac_udata->heap_addr;
-
- while (i<sym->nsyms && shadow) {
- /* Advance the Entry ptr until it gets to the next shadow. */
- while (i<sym->nsyms &&
- (s=H5H_peek (f, &heap_addr, sym->entry[i].name_off)) &&
- strcmp (s, shadow->name)<0) i++;
-
- /* Advance the Shadow ptr until it gets to the next entry. */
- while (i<sym->nsyms && s && shadow &&
- strcmp (s, shadow->name)>0) shadow = shadow->next;
-
- /* Did we find a match? */
- if (i<sym->nsyms && s && shadow && !strcmp (s, shadow->name)) {
- shadow->main = sym->entry + i;
- sym->entry[i].shadow = shadow;
- i++;
- shadow = shadow->next;
- }
- }
- }
-
- FUNC_LEAVE (SUCCEED);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_open
- *
- * Purpose: Given a handle to an already open object, or given a
- * pointer to the cached symbol table entry for that
- * object, open the object (again) and return a handle
- * to it.
- *
- * If ENT refers to the root object, then GRP can be a null
- * pointer or a pointer to an entry with an invalid header
- * address.
- *
- * Return: Success: Handle to open object
- *
- * Failure: NULL
- *
- * Programmer: Robb Matzke
- * Thursday, September 18, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-H5G_entry_t *
-H5G_shadow_open (H5F_t *f, H5G_entry_t *grp, H5G_entry_t *ent)
-{
- H5G_shadow_t *shadow = NULL;
- H5O_stab_t stab;
- const char *s = NULL;
- H5G_hash_t *hash = NULL;
- H5G_shadow_t *hash_ent = NULL, *prev_ent = NULL;
- uintn idx;
- H5O_name_t name_mesg = {NULL};
- H5G_entry_t *ret_value = NULL;
- haddr_t grp_header;
-
- FUNC_ENTER (H5G_shadow_open, NULL);
-
- /* check args */
- assert (f);
- assert (ent);
-
- if ((shadow = ent->shadow)) {
- /* Object is already open. Open it again */
- shadow->nrefs += 1;
- HRETURN (&(shadow->entry));
- }
-
- /*
- * If the root object is being opened then the GRP argument is optional.
- * If it's supplied then it had better have an undefined header address.
- * For all other objects the GRP argument is required to have a valid
- * header address.
- */
- if (ent==f->shared->root_sym) {
- assert (!grp || !H5F_addr_defined (&(grp->header)));
- H5F_addr_undef (&grp_header);
- idx = 0;
- } else {
- assert (grp && H5F_addr_defined (&(grp->header)));
- grp_header = grp->header;
- idx = H5F_addr_hash (&grp_header, f->shared->nshadows);
- }
-
- /*
- * Build the new shadow.
- */
- shadow = H5MM_xcalloc (1, sizeof(H5G_shadow_t));
- ent->shadow = shadow;
- shadow->main = ent;
- shadow->nrefs = 1;
- shadow->entry = *ent;
- shadow->entry.dirty = FALSE;
- shadow->grp_addr = grp_header;
-
- /*
- * Give the shadow a name. Obtaining the name might remove ENT from the
- * cache, so we're careful not to reference it again.
- */
- if (ent==f->shared->root_sym) {
- /*
- * We're opening the root entry. Get the name from the name message or
- * use a generic default.
- */
- if (H5O_read (f, NO_ADDR, ent, H5O_NAME, 0, &name_mesg)) {
- shadow->name = H5MM_xstrdup (name_mesg.s);
- H5O_reset (H5O_NAME, &name_mesg);
- } else {
- shadow->name = H5MM_xstrdup ("Root Object");
- }
-
- } else {
- /*
- * Some entry other than the root.
- */
- if (NULL==H5O_read (f, NO_ADDR, grp, H5O_STAB, 0, &stab)) {
- HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
- "unable to read symbol table object header message");
- }
- if (NULL==(s=H5H_peek (f, &(stab.heap_addr), ent->name_off))) {
- HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
- "unable to read symbol name");
- }
- shadow->name = H5MM_xstrdup (s);
- }
- ent = NULL; /*previous ops might have invalidated it*/
-
-
- /*
- * Link it into the shadow heap
- */
- for (hash=f->shared->shadow[idx]; hash; hash=hash->next) {
- if (0==idx &&
- !H5F_addr_defined (&(hash->grp_addr)) &&
- !H5F_addr_defined (&grp_header)) {
- break; /*shadow list for root object*/
- } else if (H5F_addr_eq (&(hash->grp_addr), &grp_header)) {
- break; /*shadow list for other objects*/
- }
- }
- if (!hash) {
- hash = H5MM_xcalloc (1, sizeof(H5G_hash_t));
- hash->grp_addr = grp_header;
- hash->next = f->shared->shadow[idx];
- f->shared->shadow[idx] = hash;
- if (hash->next) hash->next->prev = hash;
- }
- if (hash->head) {
- for (hash_ent=hash->head,prev_ent=NULL;
- hash_ent;
- hash_ent=hash_ent->next) {
- if (strcmp (shadow->name, hash_ent->name)<0) break;
- prev_ent = hash_ent;
- }
- if (hash_ent) {
- /* Insert SHADOW before HASH_ENT */
- if (hash_ent->prev) hash_ent->prev->next = shadow;
- else hash->head = shadow;
- shadow->prev = hash_ent->prev;
- shadow->next = hash_ent;
- hash_ent->prev = shadow;
- } else {
- /* Append SHADOW to list */
- assert (prev_ent && NULL==prev_ent->next);
- prev_ent->next = shadow;
- shadow->prev = prev_ent;
- }
- } else {
- /* Insert shadow at head of list */
- shadow->next = hash->head;
- if (hash->head) hash->head->prev = shadow;
- hash->head = shadow;
- }
-
-#ifdef H5G_DEBUG
- H5G_shadow_check (f);
-#endif
-
- ret_value = &(shadow->entry);
-
- done:
- if (!ret_value) {
- if (shadow) {
- H5MM_xfree (shadow->name);
- H5MM_xfree (shadow);
- }
- }
-
- FUNC_LEAVE (ret_value);
-}
-
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_close
- *
- * Purpose: Closes an open object.
- *
- * Return: Success: SUCCEED
- *
- * Failure: FAIL
- *
- * Programmer: Robb Matzke
- * Thursday, September 18, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_shadow_close (H5F_t *f, H5G_entry_t *ent)
-{
- uintn idx;
- H5G_hash_t *hash=NULL;
- H5G_shadow_t *hash_ent=NULL, *shadow=NULL;
-
- FUNC_ENTER (H5G_shadow_close, FAIL);
-
- /* check args */
- assert (ent);
- assert (H5G_shadow_p (ent));
- assert (ent->shadow->nrefs>0);
- shadow = ent->shadow;
-
- /* clean the shadow */
- if (1==shadow->nrefs && ent->dirty) {
- if (!shadow->main &&
- NULL==H5G_stab_find (f, &(shadow->grp_addr), NULL, shadow->name)) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
- "unable to find shadow name in symbol table");
- }
- assert (shadow->main);
- *(shadow->main) = *ent;
- ent->dirty = FALSE;
- }
-
- /* close */
- shadow->nrefs -= 1;
-
- if (0==shadow->nrefs) {
- /* dissociate shadow and entry */
- H5G_shadow_dissociate (ent);
-
- /*
- * find symtabs shadow list -- if this is a shadow of the root object
- * then use zero for the hash value. The root object always has an
- * undefined group address.
- */
- if (H5F_addr_defined (&(shadow->grp_addr))) {
- idx = H5F_addr_hash (&(shadow->grp_addr), f->shared->nshadows);
- } else {
- idx = 0;
- }
- for (hash=f->shared->shadow[idx]; hash; hash=hash->next) {
- if (0==idx &&
- !H5F_addr_defined (&(hash->grp_addr)) &&
- !H5F_addr_defined (&(shadow->grp_addr))) {
- break; /*shadow list for root object*/
- } else if (H5F_addr_eq (&(hash->grp_addr), &(shadow->grp_addr))) {
- break; /*shadow list for other objects*/
- }
- }
- assert (hash);
-
- /* find shadow in shadow list */
- for (hash_ent=hash->head; hash_ent; hash_ent=hash_ent->next) {
- if (hash_ent==shadow) break;
- }
- assert (hash_ent);
-
- /* remove shadow from shadow list */
- if (hash_ent->prev) hash_ent->prev->next = hash_ent->next;
- else hash->head = hash_ent->next;
- if (hash_ent->next) hash_ent->next->prev = hash_ent->prev;
- H5MM_xfree (shadow->name);
- H5MM_xfree (shadow);
-
- /* remove symtab's shadow list if empty */
- if (!hash->head) {
- if (hash->prev) hash->prev->next = hash->next;
- else f->shared->shadow[idx] = hash->next;
- if (hash->next) hash->next->prev = hash->prev;
- H5MM_xfree (hash);
- }
- }
-
- FUNC_LEAVE (SUCCEED);
-}
-
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_move
- *
- * Purpose: Moves the SHADOW for some entry to correspond to a
- * NEW_ENTRY. The GRP_ADDR is the address for the group
- * which contains NEW_ENTRY.
- *
- * Return: Success: SUCCEED
- *
- * Failure: FAIL
- *
- * Programmer: Robb Matzke
- * Friday, September 19, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_shadow_move (H5F_t *f, H5G_shadow_t *shadow, const char *new_name,
- H5G_entry_t *new_entry, const haddr_t *grp_addr)
-{
- H5G_hash_t *hash;
- uintn idx;
-
- FUNC_ENTER (H5G_shadow_move, FAIL);
-
- assert (shadow);
- assert (new_entry);
- assert (grp_addr && H5F_addr_defined (grp_addr));
-
- if (!H5F_addr_defined (&(shadow->grp_addr))) {
- /*
- * We're moving the shadow for the root object. This simplifies things
- * greatly since it implies that this is the only shadow currently
- * defined for the entire file.
- */
- idx = H5F_addr_hash (grp_addr, f->shared->nshadows);
- assert (NULL==f->shared->shadow[idx]); /*Nothing at new idx... */
- hash = f->shared->shadow[0];
- assert (hash); /*..but root idx has something. */
- assert (!H5F_addr_defined (&(hash->grp_addr)));/*..it's the root obj*/
- assert (NULL==hash->next); /*..and just that */
- assert (hash->head==shadow); /*..and exactly that */
-
- /* Move root entry to new hash bucket */
- f->shared->shadow[idx] = hash;
- f->shared->shadow[0] = NULL;
- hash->grp_addr = *grp_addr;
-
- /* Associate SHADOW with NEW_ENTRY */
- shadow->grp_addr = *grp_addr;
- shadow->main = new_entry;
- new_entry->shadow = shadow;
-
- /* Give the shadow a new name */
- H5MM_xfree (shadow->name);
- shadow->name = H5MM_xstrdup (new_name);
-
- } else {
- /*
- * Other shadows never move.
- */
- assert (H5F_addr_eq (&(shadow->grp_addr), grp_addr));
- shadow->main = new_entry;
- new_entry->shadow = shadow;
- }
-
- FUNC_LEAVE (SUCCEED);
-}
-
-
-
-/*-------------------------------------------------------------------------
- * Function: H5G_shadow_flush
- *
- * Purpose: Flush all open object information to the main cache.
- *
- * Return: Success: SUCCEED
- *
- * Failure: FAIL if INVALIDATE is non-zero and there are
- * open objects.
- *
- * Programmer: Robb Matzke
- * Friday, September 19, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_shadow_flush (H5F_t *f, hbool_t invalidate)
-{
- uintn idx;
- H5G_hash_t *hash = NULL;
- H5G_shadow_t *shadow = NULL;
- intn nfound=0;
-
- FUNC_ENTER (H5G_shadow_flush, FAIL);
-
- for (idx=0; idx<f->shared->nshadows; idx++) {
- for (hash=f->shared->shadow[idx]; hash; hash=hash->next) {
- for (shadow=hash->head; shadow; shadow=shadow->next) {
- /*
- * If the shadow is dirty, then transfer the shadow info to the
- * symbol table node.
- */
- if (shadow->entry.dirty) {
- if (0==idx && !H5F_addr_defined (&(shadow->grp_addr)) &&
- shadow->main==f->shared->root_sym) {
- /*
- * The shadow for the root entry gets copied back into the
- * root symbol
- */
- *f->shared->root_sym = shadow->entry;
- } else {
- /*
- * Other shadows get copied back into the symbol table.
- */
- if (!shadow->main &&
- NULL==H5G_stab_find (f, &(shadow->grp_addr), NULL,
- shadow->name)) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
- "unable to find shadow name in symbol "
- "table");
- }
- assert (shadow->main);
- *(shadow->main) = shadow->entry;
- shadow->entry.dirty = FALSE;
- nfound++;
- }
- }
-#ifndef NDEBUG
- /*
- * This is usually a bad thing--an hdf5 programmer forgot to close
- * some object before closing the file. Since this is hard to
- * debug, we'll be nice and print the names here. We don't know
- * the full name, but we'll print the relative file address
- * of the object header for the group that contains the open
- * object.
- */
- if (invalidate) {
- fprintf (stderr, "HDF5-DIAG: warning: open object <");
- H5F_addr_print (stderr, &(shadow->grp_addr));
- fprintf (stderr, ">/%s", shadow->name);
- if (shadow->nrefs>1) {
- fprintf (stderr, " (%d times)", shadow->nrefs);
- }
- fputc ('\n', stderr);
- }
-#endif
- }
- }
- }
-
- if (invalidate && nfound) {
- /*
- * No clean easy way to do this, just leak the memory. If we free a
- * shadow and then something else tries to access it (perhaps to close
- * it) then they trample on freed memory.
- */
- HRETURN_ERROR (H5E_SYM, H5E_UNSUPPORTED, FAIL,
- "leaking memory due to shadow errors");
- }
-
- FUNC_LEAVE (SUCCEED);
-}
diff --git a/src/H5Gstab.c b/src/H5Gstab.c
index a607e5e..1cf36ec 100644
--- a/src/H5Gstab.c
+++ b/src/H5Gstab.c
@@ -26,21 +26,14 @@ static hbool_t interface_initialize_g = FALSE;
*
* Purpose: Creates a new empty symbol table (object header, name heap,
* and B-tree). The caller can specify an initial size for the
- * name heap.
+ * name heap. The object header of the group is opened for
+ * write access.
*
* In order for the B-tree to operate correctly, the first
* item in the heap is the empty string, and must appear at
* heap offset zero.
*
* Errors:
- * INTERNAL CANTINIT B-tree's won't work if the first
- * name isn't at the beginning of the
- * heap.
- * SYM CANTINIT Can't create B-tree.
- * SYM CANTINIT Can't create header.
- * SYM CANTINIT Can't create heap.
- * SYM CANTINIT Can't create message.
- * SYM CANTINIT Can't initialize heap.
*
* Return: Success: SUCCEED
*
@@ -55,10 +48,9 @@ static hbool_t interface_initialize_g = FALSE;
*-------------------------------------------------------------------------
*/
herr_t
-H5G_stab_create (H5F_t *f, H5G_entry_t *self, size_t init)
+H5G_stab_create (H5F_t *f, size_t init, H5G_entry_t *self/*out*/)
{
size_t name; /*offset of "" name */
- haddr_t addr; /*object header address */
H5O_stab_t stab; /*symbol table message */
FUNC_ENTER (H5G_stab_create, FAIL);
@@ -77,14 +69,11 @@ H5G_stab_create (H5F_t *f, H5G_entry_t *self, size_t init)
if ((name = H5H_insert (f, &(stab.heap_addr), 1, "")<0)) {
HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't initialize heap");
}
- if (0!=name) {
- /*
- * B-tree's won't work if the first name isn't at the beginning
- * of the heap.
- */
- HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL,
- "internal error (heap doesn't begin at zero)");
- }
+ /*
+ * B-tree's won't work if the first name isn't at the beginning
+ * of the heap.
+ */
+ assert (0==name);
/* Create the B-tree */
if (H5B_create (f, H5B_SNODE, NULL, &(stab.btree_addr)/*out*/)<0) {
@@ -96,14 +85,13 @@ H5G_stab_create (H5F_t *f, H5G_entry_t *self, size_t init)
* since nothing refers to it yet. The link count will be
* incremented if the object is added to the group directed graph.
*/
- if (H5O_create (f, 0, 4+2*H5F_SIZEOF_ADDR(f), &addr/*out*/)<0) {
+ if (H5O_create (f, 4+2*H5F_SIZEOF_ADDR(f), self/*out*/)<0) {
HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't create header");
}
/* insert the symbol table message */
- memset (self, 0, sizeof(H5G_entry_t));
- self->header = addr;
- if (H5O_modify(f, NO_ADDR, self, H5O_STAB, H5O_NEW_MESG, &stab)<0) {
+ if (H5O_modify (f, self, H5O_STAB, H5O_NEW_MESG, &stab)<0) {
+ H5O_close (f, self);
HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't create message");
}
@@ -115,23 +103,14 @@ H5G_stab_create (H5F_t *f, H5G_entry_t *self, size_t init)
* Function: H5G_stab_find
*
* Purpose: Finds a symbol named NAME in the symbol table whose
- * description is stored in SELF in file F and returns a
- * pointer to the symbol table entry. SELF is optional if the
- * symbol table address is supplied through ADDR.
+ * description is stored in GRP_ENT in file F and returns its
+ * symbol table entry through OBJ_ENT (which is optional).
*
* Errors:
- * SYM BADMESG Can't read message.
- * SYM NOTFOUND Not found.
*
- * Return: Success: Pointer to the symbol table entry.
- * The pointer is intended for immediate
- * read-only access since it points
- * directly to an entry in a cached
- * symbol table node. The pointer is
- * guaranteed to be valid only until the
- * next call to one of the H5AC functions.
+ * Return: Success: SUCCEED
*
- * Failure: NULL
+ * Failure: FAIL
*
* Programmer: Robb Matzke
* matzke@llnl.gov
@@ -141,75 +120,50 @@ H5G_stab_create (H5F_t *f, H5G_entry_t *self, size_t init)
*
*-------------------------------------------------------------------------
*/
-H5G_entry_t *
-H5G_stab_find (H5F_t *f, const haddr_t *addr, H5G_entry_t *self,
- const char *name)
+herr_t
+H5G_stab_find (H5F_t *f, H5G_entry_t *grp_ent, const char *name,
+ H5G_entry_t *obj_ent/*out*/)
{
H5G_bt_ud1_t udata; /*data to pass through B-tree */
H5O_stab_t stab; /*symbol table message */
- FUNC_ENTER (H5G_stab_find, NULL);
+ FUNC_ENTER (H5G_stab_find, FAIL);
/* Check arguments */
assert (f);
- assert (!addr || H5F_addr_defined (addr));
- if (!addr && (!self || !H5F_addr_defined (&(self->header)))) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "bad address");
- }
- if (!name || !*name) {
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "no name");
- }
- if (!addr) addr = &(self->header);
+ assert (grp_ent);
+ assert (name && *name);
/* set up the udata */
- if (NULL==H5O_read (f, addr, self, H5O_STAB, 0, &stab)) {
- HRETURN_ERROR (H5E_SYM, H5E_BADMESG, NULL, "can't read message");
+ if (NULL==H5O_read (f, grp_ent, H5O_STAB, 0, &stab)) {
+ HRETURN_ERROR (H5E_SYM, H5E_BADMESG, FAIL, "can't read message");
}
udata.operation = H5G_OPER_FIND;
udata.name = name;
udata.heap_addr = stab.heap_addr;
- udata.grp_addr = *addr;
- udata.node_ptr = NULL;
/* search the B-tree */
if (H5B_find (f, H5B_SNODE, &(stab.btree_addr), &udata)<0) {
- if (udata.node_ptr) {
- H5AC_unprotect (f, H5AC_SNODE, &(udata.node_addr), udata.node_ptr);
- }
- HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "not found");
- }
-
- /* Unprotect the symbol table node */
- if (udata.node_ptr) {
- if (H5AC_unprotect (f, H5AC_SNODE, &(udata.node_addr),
- udata.node_ptr)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_PROTECT, NULL,
- "unable to release symbol table node");
- }
+ HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "not found");
}
- /* return the result */
- FUNC_LEAVE (udata.entry_ptr);
+ if (obj_ent) *obj_ent = udata.ent;
+ FUNC_LEAVE (SUCCEED);
}
/*-------------------------------------------------------------------------
* Function: H5G_stab_insert
*
- * Purpose: Insert a new symbol into the table described by SELF in
+ * Purpose: Insert a new symbol into the table described by GRP_ENT in
* file F. The name of the new symbol is NAME and its symbol
- * table entry is ENT.
+ * table entry is OBJ_ENT.
*
* Errors:
- * SYM BADMESG Can't read message.
- * SYM CANTINSERT Can't insert entry.
*
- * Return: Success: Pointer to the cached symbol table entry.
- * This is a pointer directly into a symbol
- * table node and will become invalid on the
- * next call to the H5AC package.
+ * Return: Success: SUCCEED
*
- * Failure: NULL
+ * Failure: FAIL
*
* Programmer: Robb Matzke
* matzke@llnl.gov
@@ -217,61 +171,41 @@ H5G_stab_find (H5F_t *f, const haddr_t *addr, H5G_entry_t *self,
*
* Modifications:
*
- * Robb Matzke, 18 Sep 1997
- * If ENT has a shadow, then the shadow will be associated with the
- * entry when it is added to the symbol table.
- *
*-------------------------------------------------------------------------
*/
-H5G_entry_t *
-H5G_stab_insert (H5F_t *f, H5G_entry_t *self, const char *name,
- H5G_entry_t *ent)
+herr_t
+H5G_stab_insert (H5F_t *f, H5G_entry_t *grp_ent, const char *name,
+ H5G_entry_t *obj_ent)
{
H5O_stab_t stab; /*symbol table message */
H5G_bt_ud1_t udata; /*data to pass through B-tree */
- FUNC_ENTER (H5G_stab_insert, NULL);
+ FUNC_ENTER (H5G_stab_insert, FAIL);
/* check arguments */
assert (f);
- assert (self && H5F_addr_defined (&(self->header)));
+ assert (grp_ent && H5F_addr_defined (&(grp_ent->header)));
assert (name && *name);
- assert (ent);
+ assert (obj_ent && H5F_addr_defined (&(obj_ent->header)));
/* initialize data to pass through B-tree */
- if (NULL==H5O_read (f, &(self->header), self, H5O_STAB, 0, &stab)) {
- HRETURN_ERROR (H5E_SYM, H5E_BADMESG, NULL, "can't read message");
+ if (NULL==H5O_read (f, grp_ent, H5O_STAB, 0, &stab)) {
+ HRETURN_ERROR (H5E_SYM, H5E_BADMESG, FAIL, "not a symbol table");
}
udata.operation = H5G_OPER_INSERT;
udata.name = name;
udata.heap_addr = stab.heap_addr;
- udata.grp_addr = self->header;
- udata.entry = *ent;
- udata.entry.name_off = -1;
- udata.node_ptr = NULL;
+ udata.ent = *obj_ent;
/* insert */
if (H5B_insert (f, H5B_SNODE, &(stab.btree_addr), &udata)<0) {
- if (udata.node_ptr) {
- H5AC_unprotect (f, H5AC_SNODE, &(udata.node_addr), udata.node_ptr);
- }
- HRETURN_ERROR (H5E_SYM, H5E_CANTINSERT, NULL, "can't insert entry");
+ HRETURN_ERROR (H5E_SYM, H5E_CANTINSERT, FAIL, "can't insert entry");
}
- /*
- * The H5G_node_insert() called H5AC_protect() for the node so that the
- * udata.entry_ptr field didn't become invalid on the way back out of the
- * B-tree code. We unprotect it now, but the pointer will remain valid
- * until the next call to H5AC.
- */
- if (H5AC_unprotect (f, H5AC_SNODE, &(udata.node_addr), udata.node_ptr)<0) {
- HRETURN_ERROR (H5E_SYM, H5E_PROTECT, NULL, "can't unprotect");
- }
-
/* update the name offset in the entry */
- ent->name_off = udata.entry.name_off;
- FUNC_LEAVE (udata.entry_ptr);
+ obj_ent->name_off = udata.ent.name_off;
+ FUNC_LEAVE (SUCCEED);
}
@@ -307,7 +241,7 @@ H5G_stab_insert (H5F_t *f, H5G_entry_t *self, const char *name,
*-------------------------------------------------------------------------
*/
intn
-H5G_stab_list (H5F_t *f, H5G_entry_t *self, intn maxentries,
+H5G_stab_list (H5F_t *f, H5G_entry_t *grp_ent, intn maxentries,
char *names[], H5G_entry_t entries[])
{
H5G_bt_ud2_t udata;
@@ -318,16 +252,15 @@ H5G_stab_list (H5F_t *f, H5G_entry_t *self, intn maxentries,
/* check args */
assert (f);
- assert (self && H5F_addr_defined (&(self->header)));
+ assert (grp_ent && H5F_addr_defined (&(grp_ent->header)));
assert (maxentries>=0);
/* initialize data to pass through B-tree */
- if (NULL==H5O_read (f, &(self->header), self, H5O_STAB, 0, &stab)) {
+ if (NULL==H5O_read (f, grp_ent, H5O_STAB, 0, &stab)) {
HRETURN_ERROR (H5E_SYM, H5E_BADMESG, FAIL, "not a symbol table");
}
udata.entry = entries;
udata.name = names;
- udata.grp_addr = self->header;
udata.heap_addr = stab.heap_addr;
udata.maxentries = maxentries;
udata.nsyms = 0;
diff --git a/src/H5O.c b/src/H5O.c
index 5ba5c22..099fde9 100644
--- a/src/H5O.c
+++ b/src/H5O.c
@@ -74,10 +74,13 @@ static const H5O_class_t *const message_type_g[] = {
* Function: H5O_create
*
* Purpose: Creates a new object header, sets the link count
- * to NLINK, and caches the header.
+ * to 0, and caches the header. The object header is opened for
+ * write access and should eventually be closed by calling
+ * H5O_close().
*
- * Return: Success: SUCCEED, the address of new header is
- * returned through the ADDR argument.
+ * Return: Success: SUCCEED, the ENT argument contains
+ * information about the object header,
+ * including its address.
*
* Failure: FAIL
*
@@ -90,7 +93,7 @@ static const H5O_class_t *const message_type_g[] = {
*-------------------------------------------------------------------------
*/
herr_t
-H5O_create (H5F_t *f, intn nlink, size_t size_hint, haddr_t *addr/*out*/)
+H5O_create (H5F_t *f, size_t size_hint, H5G_entry_t *ent/*out*/)
{
size_t size; /*total size of object header */
H5O_t *oh = NULL;
@@ -100,14 +103,14 @@ H5O_create (H5F_t *f, intn nlink, size_t size_hint, haddr_t *addr/*out*/)
/* check args */
assert (f);
- assert (nlink>=0);
- assert (addr);
+ assert (ent);
+ HDmemset (ent, 0, sizeof(H5G_entry_t));
if (size_hint<H5O_MIN_SIZE) size_hint = H5O_MIN_SIZE;
H5O_ALIGN (size_hint, H5O_ALIGNMENT);
/* allocate disk space for header and first chunk */
size = H5O_SIZEOF_HDR(f) + size_hint;
- if (H5MF_alloc (f, H5MF_META, size, addr/*out*/)<0) {
+ if (H5MF_alloc (f, H5MF_META, size, &(ent->header)/*out*/)<0) {
HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
"unable to allocate file space for object header hdr");
}
@@ -117,14 +120,14 @@ H5O_create (H5F_t *f, intn nlink, size_t size_hint, haddr_t *addr/*out*/)
oh->dirty = TRUE;
oh->version = H5O_VERSION;
oh->alignment = H5O_ALIGNMENT;
- oh->nlink = nlink;
+ oh->nlink = 0;
/* create the chunk list and initialize the first chunk */
oh->nchunks = 1;
oh->alloc_nchunks = H5O_NCHUNKS;
oh->chunk = H5MM_xmalloc (oh->alloc_nchunks * sizeof (H5O_chunk_t));
- tmp_addr = *addr;
+ tmp_addr = ent->header;
H5F_addr_inc (&tmp_addr, H5O_SIZEOF_HDR (f));
oh->chunk[0].dirty = TRUE;
oh->chunk[0].addr = tmp_addr;
@@ -144,12 +147,82 @@ H5O_create (H5F_t *f, intn nlink, size_t size_hint, haddr_t *addr/*out*/)
oh->mesg[0].chunkno = 0;
/* cache it */
- if (H5AC_set (f, H5AC_OHDR, addr, oh)<0) {
+ if (H5AC_set (f, H5AC_OHDR, &(ent->header), oh)<0) {
H5MM_xfree (oh);
HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL,
"unable to cache object header");
}
+ /* open it */
+ if (H5O_open (f, ent)<0) {
+ HRETURN_ERROR (H5E_OHDR, H5E_CANTOPENOBJ, FAIL,
+ "unable to open object header");
+ }
+
+ FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5O_open
+ *
+ * Purpose: Opens an object header which is described by the symbol table
+ * entry OBJ_ENT.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Monday, January 5, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5O_open (H5F_t *f, H5G_entry_t *obj_ent)
+{
+ FUNC_ENTER (H5O_open, FAIL);
+
+ /*
+ * There is nothing to do here now. Opening an object header should
+ * eventually do something to prevent the object header from being deleted,
+ * but since object deletion isn't implemented yet, we don't care.
+ */
+
+ FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5O_close
+ *
+ * Purpose: Closes an object header that was previously open.
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Robb Matzke
+ * Monday, January 5, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5O_close (H5F_t *f, H5G_entry_t *obj_ent)
+{
+ FUNC_ENTER (H5O_close, FAIL);
+
+ /*
+ * There is nothing to do here now. See H5O_open(). Eventually this
+ * function will free resources if the object header hard link count is
+ * zero and this was the last oustanding open for the object. Since
+ * object deletion isn't implemented yet, we don't care.
+ */
+
FUNC_LEAVE (SUCCEED);
}
@@ -590,52 +663,40 @@ H5O_link (H5F_t *f, H5G_entry_t *ent, intn adjust)
*-------------------------------------------------------------------------
*/
void *
-H5O_read (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
- const H5O_class_t *type, intn sequence, void *mesg)
+H5O_read (H5F_t *f, H5G_entry_t *ent, const H5O_class_t *type,
+ intn sequence, void *mesg)
{
H5O_t *oh = NULL;
void *retval = NULL;
intn idx;
H5G_cache_t *cache = NULL;
H5G_type_t cache_type;
- haddr_t _addr;
FUNC_ENTER (H5O_read, NULL);
/* check args */
assert (f);
- if (!addr) {
- if (!ent || H5G_ent_addr (ent, &_addr/*out*/)) {
- HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL,
- "invalid symbol table entry");
- }
- addr = &_addr;
- }
- assert (H5F_addr_defined (addr));
+ assert (ent);
+ assert (H5F_addr_defined (&(ent->header)));
+ assert (type);
assert (sequence>=0);
/* can we get it from the symbol table? */
- if (ent) {
- cache = H5G_ent_cache (ent, &cache_type);
- if (type && cache_type==type->cache_type && type->fast) {
- retval = (type->fast)(cache, mesg);
- if (retval) HRETURN (retval);
- H5ECLEAR;
- }
+ cache = H5G_ent_cache (ent, &cache_type);
+ if (type && cache_type==type->cache_type && type->fast) {
+ retval = (type->fast)(cache, mesg);
+ if (retval) HRETURN (retval);
+ H5ECLEAR;
}
/* can we get it from the object header? */
- if ((idx = H5O_find_in_ohdr (f, addr, &type, sequence))<0) {
+ if ((idx = H5O_find_in_ohdr (f, &(ent->header), &type, sequence))<0) {
HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL,
"unable to find message in object header");
}
-#ifdef LATER
- /* should we cache it in ENT? */
-#endif
-
/* copy the message to the user-supplied buffer */
- if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
+ if (NULL==(oh=H5AC_find (f, H5AC_OHDR, &(ent->header), NULL, NULL))) {
HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, NULL,
"unable to load object header");
}
@@ -740,7 +801,7 @@ H5O_find_in_ohdr (H5F_t *f, const haddr_t *addr, const H5O_class_t **type_p,
*-------------------------------------------------------------------------
*/
const void *
-H5O_peek (H5F_t *f, const haddr_t *addr, const H5O_class_t *type,
+H5O_peek (H5F_t *f, H5G_entry_t *ent, const H5O_class_t *type,
intn sequence)
{
intn idx;
@@ -750,13 +811,13 @@ H5O_peek (H5F_t *f, const haddr_t *addr, const H5O_class_t *type,
/* check args */
assert (f);
- assert (addr && H5F_addr_defined (addr));
+ assert (ent && H5F_addr_defined (&(ent->header)));
- if ((idx = H5O_find_in_ohdr (f, addr, &type, sequence))<0) {
+ if ((idx = H5O_find_in_ohdr (f, &(ent->header), &type, sequence))<0) {
HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL,
"unable to find object header message");
}
- if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
+ if (NULL==(oh=H5AC_find (f, H5AC_OHDR, &(ent->header), NULL, NULL))) {
HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, NULL,
"unable to load object header");
}
@@ -769,11 +830,8 @@ H5O_peek (H5F_t *f, const haddr_t *addr, const H5O_class_t *type,
* Function: H5O_modify
*
* Purpose: Modifies an existing message or creates a new message.
- * The object header is at file address ADDR of file F (but if
- * ENT is present then its `header' field is used instead). An
- * optional symbol table entry ENT can be supplied in which
- * case the cache fields in that symbol table are updated if
- * appropriate.
+ * The cache fields in that symbol table entry ENT are updated
+ * as appropriate.
*
* The OVERWRITE argument is either a sequence number of a
* message to overwrite (usually zero) or the constant
@@ -798,30 +856,23 @@ H5O_peek (H5F_t *f, const haddr_t *addr, const H5O_class_t *type,
*-------------------------------------------------------------------------
*/
intn
-H5O_modify (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
- const H5O_class_t *type, intn overwrite, const void *mesg)
+H5O_modify (H5F_t *f, H5G_entry_t *ent, const H5O_class_t *type,
+ intn overwrite, const void *mesg)
{
H5O_t *oh = NULL;
intn idx, sequence;
size_t size;
- haddr_t _addr;
FUNC_ENTER (H5O_modify, FAIL);
/* check args */
assert (f);
+ assert (ent);
+ assert (H5F_addr_defined (&(ent->header)));
assert (type);
assert (mesg);
- if (!addr) {
- if (!ent || H5G_ent_addr (ent, &_addr)<0) {
- HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL,
- "invalid object header address");
- }
- addr = &_addr;
- }
- assert (H5F_addr_defined (addr));
- if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
+ if (NULL==(oh=H5AC_find (f, H5AC_OHDR, &(ent->header), NULL, NULL))) {
HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL,
"unable to load object header");
}
@@ -866,7 +917,7 @@ H5O_modify (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
oh->dirty = TRUE;
/* Copy into the symbol table entry */
- if (oh->nlink<=1 && ent && type->cache) {
+ if (oh->nlink<=1 && type->cache) {
H5G_type_t cache_type;
H5G_cache_t *cache = H5G_ent_cache (ent, &cache_type);
hbool_t modified = (type->cache)(&cache_type, cache, mesg);
@@ -909,29 +960,21 @@ H5O_modify (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
*-------------------------------------------------------------------------
*/
herr_t
-H5O_remove (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
- const H5O_class_t *type, intn sequence)
+H5O_remove (H5F_t *f, H5G_entry_t *ent, const H5O_class_t *type, intn sequence)
{
H5O_t *oh = NULL;
intn i, seq;
- haddr_t _addr;
FUNC_ENTER (H5O_remove, FAIL);
/* check args */
assert (f);
+ assert (ent);
+ assert (H5F_addr_defined (&(ent->header)));
assert (type);
- if (!addr) {
- if (!ent || H5G_ent_addr (ent, &_addr)<0) {
- HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL,
- "invalid object header address");
- }
- addr = &_addr;
- }
- assert (H5F_addr_defined (addr));
/* load the object header */
- if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
+ if (NULL==(oh=H5AC_find (f, H5AC_OHDR, &(ent->header), NULL, NULL))) {
HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL,
"unable to load object header");
}
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index 8d00117..da682c6 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -180,16 +180,18 @@ typedef struct H5O_stab_t {
-herr_t H5O_create (H5F_t *f, intn nlink, size_t size_hint, haddr_t*);
+herr_t H5O_create (H5F_t *f, size_t size_hint, H5G_entry_t *ent/*out*/);
+herr_t H5O_open (H5F_t *f, H5G_entry_t *ent);
+herr_t H5O_close (H5F_t *f, H5G_entry_t *ent);
intn H5O_link (H5F_t *f, H5G_entry_t *ent, intn adjust);
-void *H5O_read (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
- const H5O_class_t *type, intn sequence, void *mesg);
-const void *H5O_peek (H5F_t *f, const haddr_t *addr, const H5O_class_t *type,
+void *H5O_read (H5F_t *f, H5G_entry_t *ent, const H5O_class_t *type,
+ intn sequence, void *mesg);
+const void *H5O_peek (H5F_t *f, H5G_entry_t *ent, const H5O_class_t *type,
intn sequence);
-intn H5O_modify (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
- const H5O_class_t *type, intn overwrite, const void *mesg);
-herr_t H5O_remove (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
- const H5O_class_t *type, intn sequence);
+intn H5O_modify (H5F_t *f, H5G_entry_t *ent, const H5O_class_t *type,
+ intn overwrite, const void *mesg);
+herr_t H5O_remove (H5F_t *f, H5G_entry_t *ent, const H5O_class_t *type,
+ intn sequence);
herr_t H5O_reset (const H5O_class_t *type, void *native);
herr_t H5O_debug (H5F_t *f, const haddr_t *addr, FILE *stream,
intn indent, intn fwidth);
diff --git a/src/H5P.c b/src/H5P.c
index 8e3651e..6dbba98 100644
--- a/src/H5P.c
+++ b/src/H5P.c
@@ -610,7 +610,7 @@ H5P_modify (H5F_t *f, H5G_entry_t *ent, const H5P_t *ds)
"scalar data spaces are not implemented yet");
case H5P_SIMPLE:
- if (H5O_modify (f, NO_ADDR, ent, H5O_SDSPACE, 0, &(ds->u.simple))<0) {
+ if (H5O_modify (f, ent, H5O_SDSPACE, 0, &(ds->u.simple))<0) {
HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL,
"can't update simple data space message");
}
@@ -658,7 +658,7 @@ H5P_read (H5F_t *f, H5G_entry_t *ent)
ds = H5MM_xcalloc (1, sizeof(H5P_t));
- if (H5O_read (f, NO_ADDR, ent, H5O_SDSPACE, 0, &(ds->u.simple))) {
+ if (H5O_read (f, ent, H5O_SDSPACE, 0, &(ds->u.simple))) {
ds->type = H5P_SIMPLE;
} else {
diff --git a/src/H5private.h b/src/H5private.h
index 6972ebf..d650c03 100644
--- a/src/H5private.h
+++ b/src/H5private.h
@@ -22,7 +22,7 @@
#include <H5public.h> /* Include Public Definitions */
/* Version #'s of library code */
-#define HDF5_MAJOR_VERSION 0 /* For major interface changes */
+#define HDF5_MAJOR_VERSION 5 /* For major interface changes */
#define HDF5_MINOR_VERSION 0 /* For minor interface changes */
#define HDF5_RELEASE_VERSION 0 /* For interface tweaks & bug-fixes */
#define HDF5_PATCH_VERSION 0 /* For small groups of bug fixes*/
diff --git a/src/Makefile.in b/src/Makefile.in
index 16086f2..0304868 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -16,10 +16,9 @@ PROGS=debug
# Source and object files for the library (lexicographically)...
LIB_SRC=H5.c H5A.c H5AC.c H5B.c H5C.c H5D.c H5Dconv.c H5E.c H5F.c H5Fcore.c \
H5Ffamily.c H5Fistore.c H5Flow.c H5Fsec2.c H5Fsplit.c H5Fstdio.c \
- H5G.c H5Gent.c H5Gnode.c H5Gshad.c H5Gstab.c H5H.c H5M.c H5MF.c \
- H5MM.c H5O.c H5Ocont.c H5Ocstore.c H5Odtype.c H5Oefl.c H5Oistore.c \
- H5Oname.c H5Onull.c H5Osdspace.c H5Ostab.c H5P.c H5T.c H5Tinit.c \
- H5V.c
+ H5G.c H5Gent.c H5Gnode.c H5Gstab.c H5H.c H5M.c H5MF.c H5MM.c H5O.c \
+ H5Ocont.c H5Ocstore.c H5Odtype.c H5Oefl.c H5Oistore.c H5Oname.c \
+ H5Onull.c H5Osdspace.c H5Ostab.c H5P.c H5T.c H5Tinit.c H5V.c
LIB_OBJ=$(LIB_SRC:.c=.o)