[svn-r1568] Changes since 19990730

----------------------

This extensive change is the virtual file layer implementation. I've
ported and tested the sec2, family, and core drivers and only ported
the mpio driver (Albert will test it).  So if you need MPIO I would
recommend sticking with the previous version for a while.

You will get a few compile warnings about split and stdio drivers not
being implemented and possibly tracing information not inserted in
some of the drivers. You can safely ignore them but I plan to fix
them.

I'm still working on the split driver because I just realized that it
needs a part of the VFL that isn't written yet.

Documentation is being updated also because there were some minor
changes (mostly just name changes). It should be available on my web
site later this week.

./MANIFEST
./src/Makefile.in
./src/hdf5.h
./src/H5Flow.c			[REMOVED]
./src/H5Fstdio.c		[REMOVED]
./src/H5Fsec2.c			[REMOVED]
./src/H5Fsplit.c		[REMOVED]
./src/H5Fmpio.c			[REMOVED]
./src/H5Ffamily.c		[REMOVED]
./src/H5Fcore.c			[REMOVED]
./src/H5MFpublic.h		[REMOVED]
./src/H5FD.c			[NEW]
./src/H5FDcore.c		[NEW]
./src/H5FDcore.h		[NEW]
./src/H5FDfamily.c		[NEW]
./src/H5FDfamily.h		[NEW]
./src/H5FDmpio.c		[NEW]
./src/H5FDmpio.h		[NEW]
./src/H5FDprivate.h		[NEW]
./src/H5FDpublic.h		[NEW]
./src/H5FDsec2.c		[NEW]
./src/H5FDsec2.h		[NEW]
	Removed/added files for virtual file layer.

./bin/trace
./src/H5.c
	Removed unused public datatypes and added new VFL public
	datatypes.

	Changed an error message.

./config/BlankForm
./config/dec-flags
./config/gnu-flags
./config/hpux10.20
./config/hpux9.03
./config/irix5.x
./config/irix6.x
./config/solaris2.x
./config/unicosmk
	Removed the H5F_OPT_SEEK and H5F_LOW_DFLT constants from the
	configuration since they're no longer applicable. The default
	file driver is always the sec2 driver and it always optimizes
	calls to lseek() or lseek64().

./config/depend.in
	C preprocessor errors generated during automatic dependency
	building are sent to /dev/null to prevent them from appearing
	twice in the make output.

./src/H5AC.c
./src/H5B.c
./src/H5D.c
./src/H5F.c
./src/H5G.c
./src/H5Gent.c
./src/H5Gnode.c
./src/H5HG.c
./src/H5HL.c
./src/H5O.c
./src/H5Oattr.c
./src/H5Odtype.c
./src/H5Oefl.c
./src/H5Oshared.c
./src/H5T.c
./src/H5detect.c
./test/ohdr.c
	Changed H5F_ADDR_UNDEF to HADDR_UNDEF to be more consistent
	with the `haddr_t' datatype which is now a public type.

./src/H5D.c
./src/H5P.c
./src/H5Ppublic.h
./src/H5Tconv.c
./test/cmpd_dset.c
./test/dsets.c
./test/overhead.c
./test/tselect.c
./test/tvltypes.c
	The H5P_DATASET_XFER constant was changed to H5P_DATA_XFER
	because the properties apply to all types of I/O operations,
	not just datasets.

./src/H5B.c
./src/H5Bprivate.h
./src/H5D.c
./src/H5Dpublic.h
./src/H5F.c
./src/H5Farray.c
./src/H5Fistore.c
./src/H5Fprivate.h
./src/H5Fpublic.h
./src/H5Gnode.c
./src/H5Gpkg.h
./src/H5HG.c
./src/H5HL.c
./src/H5O.c
./src/H5R.c
./src/H5Sall.c
./src/H5Shyper.c
./src/H5Smpio.c
./src/H5Spoint.c
./src/H5Sprivate.h
./test/big.c
./test/h5test.c
./test/istore.c
./testpar/t_dset.c
./testpar/t_file.c
./tools/h5debug.c
./tools/h5ls.c
	Modified to work with the virtual file layer by calling H5FD_*
	functions instead of H5F_low_* functions and by passing file
	access and data transfer properties by object ID instead of
	pointer.

	Changed H5D_transfer_t to H5FD_mpio_xfer_t since the
	COLLECTIVE vs. INDEPENDENT transfer mode is specific to the
	MPIO file driver.

	Moved MPIO-specific stuff into the MPIO driver.

./src/H5B.c
./src/H5D.c
./src/H5Fprivate.h
	The H5F_mpio_* private functions were renamed and placed in
	the H5FDmpio driver except those which appeared in H5Smpio.c.

./src/H5E.c
./src/H5Epublic.h
	Added major error number H5E_VFL for virtual file layer
	related errors.

./src/H5F.c
./src/H5Fprivate.h
	Changed the logic that controls whether the boot block is
	written. Instead of assuming that the first call to write the
	boot block is only to allocate space, I've added a function
	argument which makes this explicit.

	Changed the way files are compared so that a driver-defined
	comparison function can be called.  Files which belong to
	different drivers are always considered different.

	Removed H5F_driver_t since file drivers are now identified by
	object ID instead of a special non-user-extendible datatype.

	Removed all the hard-coded low-level file properties which
	have been replaced by the various file drivers.

./src/H5I.c
./src/H5Iprivate.h
	Added the H5I_inc_ref() which was removed a few months ago
	since we finally have a use for it.

./src/H5Ipublic.h
	Added the H5I_VFL object ID type to identify file drivers in
	the virtual file layer.

./src/H5MF.c
./src/H5MFprivate.h
	Moved all the allocation/deallocation code into the virtual
	file layer which allows file drivers to override much of it.

./src/H5P.c
./src/H5Ppublic.h
	Moved file driver-specific code into the various file driver
	files.

	The H5Pcopy() and H5Pclose() functions make calls into the
	virtual file driver to manage the memory for driver-specific
	file access and data transfer properties.

./src/H5private.h
./src/H5public.h
	The `haddr_t' type is now public.

./test/tfile.c
	Added a few more comments.

1 files changed, 777 insertions, 0 deletions

diff --git a/src/H5FDfamily.c b/src/H5FDfamily.c
new file mode 100644
index 0000000..bf46efc
--- /dev/null
+++ b/src/H5FDfamily.c
@@ -0,0 +1,777 @@
+/*
+ * Copyright (C) 1997 NCSA
+ *		      All rights reserved.
+ *
+ * Programmer:	Robb Matzke <matzke@llnl.gov>
+ *		Monday, November 10, 1997
+ *
+ * Purpose:	Implements a family of files that acts as a single hdf5
+ *		file.  The purpose is to be able to split a huge file on a
+ *		64-bit platform, transfer all the <2GB members to a 32-bit
+ *		platform, and then access the entire huge file on the 32-bit
+ *		platform.
+ *
+ *		All family members are logically the same size although their
+ *		physical sizes may vary.  The logical member size is
+ *		determined by looking at the physical size of the first member
+ *		when the file is opened.  When creating a file family, the
+ *		first member is created with a predefined physical size
+ *		(actually, this happens when the file family is flushed, and
+ *		can be quite time consuming on file systems that don't
+ *		implement holes, like nfs).
+ *		
+ */
+#include <assert.h>
+#include <hdf5.h>
+#include <stdlib.h>
+
+#undef MAX
+#define MAX(X,Y)	((X)>(Y)?(X):(Y))
+#undef MIN
+#define MIN(X,Y)	((X)<(Y)?(X):(Y))
+
+/* The driver identification number, initialized at runtime */
+static hid_t H5FD_FAMILY_g = 0;
+
+/* The description of a file belonging to this driver. */
+typedef struct H5FD_family_t {
+    H5FD_t	pub;		/*public stuff, must be first		*/
+    hid_t	memb_fapl_id;	/*file access property list for members	*/
+    hsize_t	memb_size;	/*maximum size of each member file	*/
+    int		nmembs;		/*number of family members		*/
+    int		amembs;		/*number of member slots allocated	*/
+    H5FD_t	**memb;		/*dynamic array of member pointers	*/
+    haddr_t	eoa;		/*end of allocated addresses		*/
+    char	*name;		/*name generator printf format		*/
+    unsigned	flags;		/*flags for opening additional members	*/
+} H5FD_family_t;
+
+/* Driver-specific file access properties */
+typedef struct H5FD_family_fapl_t {
+    hsize_t	memb_size;	/*size of each member			*/
+    hid_t	memb_fapl_id;	/*file access property list of each memb*/
+} H5FD_family_fapl_t;
+
+/* Driver specific data transfer properties */
+typedef struct H5FD_family_dxpl_t {
+    hid_t	memb_dxpl_id;	/*data xfer property list of each memb	*/
+} H5FD_family_dxpl_t;
+
+/* Callback prototypes */
+static void *H5FD_family_fapl_copy(const void *_old_fa);
+static herr_t H5FD_family_fapl_free(void *_fa);
+static void *H5FD_family_dxpl_copy(const void *_old_dx);
+static herr_t H5FD_family_dxpl_free(void *_dx);
+static H5FD_t *H5FD_family_open(const char *name, unsigned flags,
+				hid_t fapl_id, haddr_t maxaddr);
+static herr_t H5FD_family_close(H5FD_t *_file);
+static int H5FD_family_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
+static haddr_t H5FD_family_get_eoa(H5FD_t *_file);
+static herr_t H5FD_family_set_eoa(H5FD_t *_file, haddr_t eoa);
+static haddr_t H5FD_family_get_eof(H5FD_t *_file);
+static herr_t H5FD_family_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr,
+			       hsize_t size, void *_buf/*out*/);
+static herr_t H5FD_family_write(H5FD_t *_file, hid_t dxpl_id, haddr_t addr,
+				hsize_t size, const void *_buf);
+static herr_t H5FD_family_flush(H5FD_t *_file);
+
+/* The class struct */
+static const H5FD_class_t H5FD_family_g = {
+    "family",					/*name			*/
+    HADDR_MAX,					/*maxaddr		*/
+    sizeof(H5FD_family_fapl_t),			/*fapl_size		*/
+    H5FD_family_fapl_copy,			/*fapl_copy		*/
+    H5FD_family_fapl_free,			/*fapl_free		*/
+    sizeof(H5FD_family_dxpl_t),			/*dxpl_size		*/
+    H5FD_family_dxpl_copy,			/*dxpl_copy		*/
+    H5FD_family_dxpl_free,			/*dxpl_free		*/
+    H5FD_family_open,				/*open			*/
+    H5FD_family_close,				/*close			*/
+    H5FD_family_cmp,				/*cmp			*/
+    NULL,					/*alloc			*/
+    NULL,					/*free			*/
+    H5FD_family_get_eoa,			/*get_eoa		*/
+    H5FD_family_set_eoa,			/*set_eoa		*/
+    H5FD_family_get_eof,			/*get_eof		*/
+    H5FD_family_read,				/*read			*/
+    H5FD_family_write,				/*write			*/
+    H5FD_family_flush,				/*flush			*/
+    H5FD_FLMAP_SINGLE,				/*fl_map		*/
+};
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_init
+ *
+ * Purpose:	Initialize this driver by registering the driver with the
+ *		library.
+ *
+ * Return:	Success:	The driver ID for the family driver.
+ *
+ *		Failure:	Negative
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5FD_family_init(void)
+{
+    if (!H5FD_FAMILY_g) {
+	H5FD_FAMILY_g = H5FDregister(&H5FD_family_g);
+    }
+    return H5FD_FAMILY_g;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Pset_fapl_family
+ *
+ * Purpose:	Sets the file access property list FAPL_ID to use the family
+ *		driver. The MEMB_SIZE is the size in bytes of each file
+ *		member (used only when creating a new file) and the
+ *		MEMB_FAPL_ID is a file access property list to be used for
+ *		each family member.
+ *
+ * Return:	Success:	Non-negative
+ *
+ *		Failure:	Negative
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Pset_fapl_family(hid_t fapl_id, hsize_t memb_size, hid_t memb_fapl_id)
+{
+    H5FD_family_fapl_t	fa;
+    
+    /*NO TRACE*/
+    
+    /* Check arguments */
+    if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
+    if (H5P_DEFAULT!=memb_fapl_id &&
+	H5P_FILE_ACCESS!=H5Pget_class(memb_fapl_id)) return -1;
+
+    /* Initialize driver specific information */
+    fa.memb_size = memb_size;
+    fa.memb_fapl_id = memb_fapl_id;
+    return H5Pset_driver(fapl_id, H5FD_FAMILY, &fa);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Pget_fapl_family
+ *
+ * Purpose:	Returns information about the family file access property
+ *		list though the function arguments.
+ *
+ * Return:	Success:	Non-negative
+ *
+ *		Failure:	Negative
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Pget_fapl_family(hid_t fapl_id, hsize_t *memb_size/*out*/,
+		   hid_t *memb_fapl_id/*out*/)
+{
+    H5FD_family_fapl_t	*fa;
+    
+    /*NO TRACE*/
+
+    if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
+    if (H5FD_FAMILY!=H5Pget_driver(fapl_id)) return -1;
+    if (NULL==(fa=H5Pget_driver_info(fapl_id))) return -1;
+    if (memb_size) *memb_size = fa->memb_size;
+    if (memb_fapl_id) *memb_fapl_id = H5Pcopy(fa->memb_fapl_id);
+    return 0;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_fapl_copy
+ *
+ * Purpose:	Copies the family-specific file access properties.
+ *
+ * Return:	Success:	Ptr to a new property list
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+H5FD_family_fapl_copy(const void *_old_fa)
+{
+    const H5FD_family_fapl_t *old_fa = (const H5FD_family_fapl_t*)_old_fa;
+    H5FD_family_fapl_t *new_fa = malloc(sizeof(H5FD_family_fapl_t));
+    assert(new_fa);
+
+    memcpy(new_fa, old_fa, sizeof(H5FD_family_fapl_t));
+    new_fa->memb_fapl_id = H5Pcopy(old_fa->memb_fapl_id);
+    return new_fa;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_fapl_free
+ *
+ * Purpose:	Frees the family-specific file access properties.
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	-1
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_family_fapl_free(void *_fa)
+{
+    H5FD_family_fapl_t	*fa = (H5FD_family_fapl_t*)_fa;
+    H5Pclose(fa->memb_fapl_id);
+    free(fa);
+    return 0;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_dxpl_copy
+ *
+ * Purpose:	Copes the family-specific data transfer properties.
+ *
+ * Return:	Success:	Ptr to new property list
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+H5FD_family_dxpl_copy(const void *_old_dx)
+{
+    const H5FD_family_dxpl_t *old_dx = (const H5FD_family_dxpl_t*)_old_dx;
+    H5FD_family_dxpl_t *new_dx = malloc(sizeof(H5FD_family_dxpl_t));
+    assert(new_dx);
+
+    memcpy(new_dx, old_dx, sizeof(H5FD_family_dxpl_t));
+    new_dx->memb_dxpl_id = H5Pcopy(old_dx->memb_dxpl_id);
+    return new_dx;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_dxpl_free
+ *
+ * Purpose:	Frees the family-specific data transfer properties.
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	-1
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_family_dxpl_free(void *_dx)
+{
+    H5FD_family_dxpl_t	*dx = (H5FD_family_dxpl_t*)_dx;
+    H5Pclose(dx->memb_dxpl_id);
+    free(dx);
+    return 0;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_open
+ *
+ * Purpose:	Creates and/or opens a family of files as an HDF5 file.
+ *
+ * Return:	Success:	A pointer to a new file dat structure. The
+ *				public fields will be initialized by the
+ *				caller, which is always H5FD_open().
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static H5FD_t *
+H5FD_family_open(const char *name, unsigned flags, hid_t fapl_id,
+		 haddr_t maxaddr)
+{
+    H5FD_family_t	*file=NULL;
+    char		memb_name[4096], temp[4096];
+    hsize_t		eof;
+    unsigned		t_flags = flags & ~H5F_ACC_CREAT;
+    
+    /* Check arguments */
+    if (!name || !*name) return NULL;
+    if (0==maxaddr || HADDR_UNDEF==maxaddr) return NULL;
+
+    /* Initialize file from file access properties */
+    if (NULL==(file=calloc(1, sizeof(H5FD_family_t)))) return NULL;
+    if (H5P_DEFAULT==fapl_id) {
+	file->memb_fapl_id = H5P_DEFAULT;
+	file->memb_size = 1024*1024*1024; /*1GB*/
+    } else {
+	H5FD_family_fapl_t *fa = H5Pget_driver_info(fapl_id);
+	file->memb_fapl_id = fa->memb_fapl_id;
+	file->memb_size = fa->memb_size;
+    }
+    file->name = malloc(strlen(name)+1);
+    strcpy(file->name, name);
+    file->flags = flags;
+    
+    /* Check that names are unique */
+    sprintf(memb_name, name, 0);
+    sprintf(temp, name, 1);
+    if (!strcmp(memb_name, temp)) return NULL;
+
+    /* Open all the family members */
+    while (1) {
+	sprintf(memb_name, name, file->nmembs);
+
+	/* Enlarge member array */
+	if (file->nmembs>=file->amembs) {
+	    int n = MAX(64, 2*file->amembs);
+	    H5FD_t **x = realloc(file->memb, n*sizeof(H5FD_t*));
+	    if (!x) goto error;
+	    file->amembs = n;
+	    file->memb = x;
+	}
+	
+	/*
+	 * Attempt to open file. If the first file cannot be opened then fail;
+	 * otherwise an open failure means that we've reached the last member.
+	 * Allow H5F_ACC_CREAT only on the first family member.
+	 */
+	H5E_BEGIN_TRY {
+	    file->memb[file->nmembs] = H5FDopen(memb_name,
+						0==file->nmembs?flags:t_flags,
+						file->memb_fapl_id,
+						HADDR_UNDEF);
+	} H5E_END_TRY;
+	if (!file->memb[file->nmembs]) {
+	    if (0==file->nmembs) goto error;
+	    H5Eclear();
+	    break;
+	}
+	file->nmembs++;
+    }
+    
+    /*
+     * The size of the first member determines the size of all the members,
+     * but if the size of the first member is zero then use the member size
+     * from the file access property list.
+     */
+    if ((eof=H5FDget_eof(file->memb[0]))) file->memb_size = eof;
+
+    return (H5FD_t*)file;
+
+ error:
+    /* Cleanup and fail */
+    if (file) {
+	int i;
+	for (i=0; i<file->nmembs; i++) {
+	    if (file->memb[i]) H5FDclose(file->memb[i]);
+	}
+	free(file);
+    }
+    return NULL;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_close
+ *
+ * Purpose:	Closes a family of files.
+ *
+ * Return:	Success:	Non-negative
+ *
+ *		Failure:	Negative with as many members closed as
+ *				possible. The only subsequent operation
+ *				permitted on the file is a close operation.
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_family_close(H5FD_t *_file)
+{
+    H5FD_family_t	*file = (H5FD_family_t*)_file;
+    int			i, nerrors=0;
+
+    /* Close as many members as possible */
+    for (i=0; i<file->nmembs; i++) {
+	if (file->memb[i]) {
+	    if (H5FDclose(file->memb[i])<0) {
+		nerrors++;
+	    } else {
+		file->memb[i] = NULL;
+	    }
+	}
+    }
+    if (nerrors) return -1;
+
+    /* Clean up other stuff */
+    H5Pclose(file->memb_fapl_id);
+    free(file->memb);
+    free(file->name);
+    free(file);
+    return 0;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_cmp
+ *
+ * Purpose:	Compares two file families to see if they are the same. It
+ *		does this by comparing the first member of the two families.
+ *
+ * Return:	Success:	like strcmp()
+ *
+ *		Failure:	never fails (arguments were checked by the
+ *				caller).
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+H5FD_family_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
+{
+    const H5FD_family_t	*f1 = (const H5FD_family_t*)_f1;
+    const H5FD_family_t	*f2 = (const H5FD_family_t*)_f2;
+
+    assert(f1->nmembs>=1 && f1->memb[0]);
+    assert(f2->nmembs>=1 && f2->memb[0]);
+    
+
+    return H5FDcmp(f1->memb[0], f2->memb[0]);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_get_eoa
+ *
+ * Purpose:	Returns the end-of-address marker for the file. The EOA
+ *		marker is the first address past the last byte allocated in
+ *		the format address space.
+ *
+ * Return:	Success:	The end-of-address-marker
+ *
+ *		Failure:	HADDR_UNDEF
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static haddr_t
+H5FD_family_get_eoa(H5FD_t *_file)
+{
+    H5FD_family_t	*file = (H5FD_family_t*)_file;
+    return file->eoa;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_set_eoa
+ *
+ * Purpose:	Set the end-of-address marker for the file.
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	-1
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_family_set_eoa(H5FD_t *_file, haddr_t eoa)
+{
+    H5FD_family_t	*file = (H5FD_family_t*)_file;
+    haddr_t		addr=eoa;
+    int			i;
+    char		memb_name[4096];
+
+    for (i=0; addr || i<file->nmembs; i++) {
+
+	/* Enlarge member array */
+	if (i>=file->amembs) {
+	    int n = MAX(64, 2*file->amembs);
+	    H5FD_t **x = realloc(file->memb, n*sizeof(H5FD_t*));
+	    if (!x) return -1;
+	    file->amembs = n;
+	    file->memb = x;
+	    file->nmembs = i;
+	}
+
+	/* Create another file if necessary */
+	if (i>=file->nmembs || !file->memb[i]) {
+	    file->nmembs = MAX(file->nmembs, i+1);
+	    sprintf(memb_name, file->name, i);
+	    H5E_BEGIN_TRY {
+		file->memb[i] = H5FDopen(memb_name, file->flags|H5F_ACC_CREAT,
+					 file->memb_fapl_id, file->memb_size);
+	    } H5E_END_TRY;
+	    if (NULL==file->memb[i]) return -1;
+	}
+	
+	/* Set the EOA marker for the member */
+	if (addr>file->memb_size) {
+	    H5FDset_eoa(file->memb[i], file->memb_size);
+	    addr -= file->memb_size;
+	} else {
+	    H5FDset_eoa(file->memb[i], addr);
+	    addr = 0;
+	}
+    }
+
+    file->eoa = eoa;
+    return 0;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_get_eof
+ *
+ * Purpose:	Returns the end-of-file marker, which is the greater of
+ *		either the total family size or the current EOA marker.
+ *
+ * Return:	Success:	End of file address, the first address past
+ *				the end of the family of files or the current
+ *				EOA, whichever is larger.
+ *
+ *		Failure:      	HADDR_UNDEF
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static haddr_t
+H5FD_family_get_eof(H5FD_t *_file)
+{
+    H5FD_family_t	*file = (H5FD_family_t*)_file;
+    haddr_t		eof;
+    int			i;
+
+    /*
+     * Find the last member that has a non-zero EOF and break out of the loop
+     * with `i' equal to that member. If all members have zero EOF then exit
+     * loop with i==0.
+     */
+    for (i=file->nmembs-1; i>=0; --i) {
+	if ((eof=H5FDget_eof(file->memb[i]))) break;
+	if (0==i) break;
+    }
+
+    /*
+     * The file size is the number of members before the i'th member plus the
+     * size of the i'th member.
+     */
+    eof += i*file->memb_size;
+    return MAX(eof, file->eoa);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_read
+ *
+ * Purpose:	Reads SIZE bytes of data from FILE beginning at address ADDR
+ *		into buffer BUF according to data transfer properties in
+ *		DXPL_ID.
+ *
+ * Return:	Success:	Zero. Result is stored in caller-supplied
+ *				buffer BUF.
+ *
+ *		Failure:	-1, contents of buffer BUF are undefined.
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_family_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
+		 void *_buf/*out*/)
+{
+    H5FD_family_t	*file = (H5FD_family_t*)_file;
+    unsigned char	*buf = (unsigned char*)_buf;
+    hid_t		memb_dxpl_id = H5P_DEFAULT;
+    int			i;
+    haddr_t		sub;
+    hsize_t		req;
+
+    /*
+     * Get the member data transfer property list. If the transfer property
+     * list does not belong to this driver then assume defaults
+     */
+    if (H5P_DEFAULT!=dxpl_id && H5FD_FAMILY==H5Pget_driver(dxpl_id)) {
+	H5FD_family_dxpl_t *dx = H5Pget_driver_info(dxpl_id);
+	assert(H5P_DATA_XFER==H5Pget_class(dxpl_id));
+	assert(dx);
+	memb_dxpl_id = dx->memb_dxpl_id;
+    }
+
+    /* Read from each member */
+    while (size>0) {
+	i = addr / file->memb_size;
+	sub = addr % file->memb_size;
+	req = MIN(size, file->memb_size-sub);
+	assert(i<file->nmembs);
+
+	if (H5FDread(file->memb[i], memb_dxpl_id, sub, req, buf)<0) {
+	    return -1;
+	}
+
+	addr += req;
+	buf += req;
+	size -= req;
+    }
+
+    return 0;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_write
+ *
+ * Purpose:	Writes SIZE bytes of data to FILE beginning at address ADDR
+ *		from buffer BUF according to data transfer properties in
+ *		DXPL_ID.
+ *
+ * Return:	Success:	Zero
+ *
+ *		Failure:	-1
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_family_write(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
+		  const void *_buf)
+{
+    H5FD_family_t	*file = (H5FD_family_t*)_file;
+    const unsigned char	*buf = (const unsigned char*)_buf;
+    hid_t		memb_dxpl_id = H5P_DEFAULT;
+    int			i;
+    haddr_t		sub;
+    hsize_t		req;
+
+    /*
+     * Get the member data transfer property list. If the transfer property
+     * list does not belong to this driver then assume defaults.
+     */
+    if (H5P_DEFAULT!=dxpl_id && H5FD_FAMILY==H5Pget_driver(dxpl_id)) {
+	H5FD_family_dxpl_t *dx = H5Pget_driver_info(dxpl_id);
+	assert(H5P_DATA_XFER==H5Pget_class(dxpl_id));
+	assert(dx);
+	memb_dxpl_id = dx->memb_dxpl_id;
+    }
+
+    /* Write to each member */
+    while (size>0) {
+	i = addr / file->memb_size;
+	sub = addr % file->memb_size;
+	req = MIN(size, file->memb_size-sub);
+	assert(i<file->nmembs);
+
+	if (H5FDwrite(file->memb[i], memb_dxpl_id, sub, req, buf)<0) {
+	    return -1;
+	}
+
+	addr += req;
+	buf += req;
+	size -= req;
+    }
+
+    return 0;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FD_family_flush
+ *
+ * Purpose:	Flushes all family members.
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	-1, as many files flushed as possible.
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, August  4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_family_flush(H5FD_t *_file)
+{
+    H5FD_family_t	*file = (H5FD_family_t*)_file;
+    int			i, nerrors=0;
+
+    for (i=0; i<file->nmembs; i++) {
+	if (file->memb[i] && H5FDflush(file->memb[i])<0) {
+	    nerrors++;
+	}
+    }
+
+    return nerrors?-1:0;
+}