Sync with develop (#3764)

* Add missing test files to distclean target (#3734)

Cleans up new files in Autotools `make distclean` in the test directory

* Add tools/libtest to Autotools builds (#3735)

This was only added to CMake many years ago and tests the tools
library.

* Clean up onion VFD files in tools `make clean` (#3739)

Cleans up h5dump and h5diff *.onion files in the Autotools when
runing `make clean`.

* Clean Java test files on Autotools (#3740)

Removes generated HDF5 and text output files when running `make clean`.

* Clean the flushrefresh test dir on Autotools (#3741)

The flushrefresh_test directory was not being cleaned up w/
`make clean` under the Autotools

* Fix file names in tfile.c (#3743)

Some tests in tfile.c use h5_fileaccess to get a VFD-dependent file
name but use the scheme from testhdf5, reusing the FILE1 and FILE8
names. This leads to files like test1.h5.h5 which are unintended
and not cleaned up.

This changes the filename scheme for a few tests to work with h5test,
resulting in more informative names and allowing the files to
be cleaned up at the end of the test. The test files have also
been added to the `make clean` target for the Autotools.

* Clean Autotools files in parallel tests (#3744)

Adds missing files to `make clean` for parallel, including Fortran.

* Add native VOL checks to deprecated functions (#3647)

* Add native VOL checks to deprecated functions

* Remove unneeded native VOL checks

* Move native checks to top level calls

* Fix buffer overflow in cache debugging code (#3691)

* update stat arg for apple (#3726)

* update stat arg for apple

* use H5_HAVE_DARWIN for Apple ifdef

* fix typo

* removed duplicate H5_ih_info_t

* added fortran async test to cmake

* Fix windows cpack error in WiX package. (#3747)

* Add a simple cache to the ros3 VFD (#3753)

Adds a small cache of the first N bytes of a file opened with the
read-only S3 (ros3) VFD, where N is 4kiB or the size of the file,
whichever is smaller. This avoids a lot of small I/O operations
on file open.

Addresses GitHub issue #3381

* Update Autotools to correctly configure oneAPI (#3751)

* Update Autotools to correctly configure oneAPI

Splits the Intel config files under the Autotools into 'classic'
Intel and oneAPI versions, fixing 'unsupported option' messages.

Also turns off `-check uninit` (new in 2023) in Fortran, which kills
the H5_buildiface program due to false positives.

* Enable Fortran in oneAPI CI workflow

* Turn on Fortran in CMake, update LD_LIBRARY_PATH

* Go back to disabling Fortran w/ Intel

For some reason there's a linking problem w/ Fortran

error while loading shared libraries: libifport.so.5: cannot open shared object file: No such file or directory

* Add h5pget_actual_selection_io_mode fortran wrapper (#3746)

* added h5pget_actual_selection_io_mode_f test

* added tests for h5pget_actual_selection_io_mode_f

* fixed int_f type conversion

* Update fortran action step (#3748)

* Added missing DLL for H5PGET_ACTUAL_SELECTION_IO_MODE_F (#3760)

* add missing H5PGET_ACTUAL_SELECTION_IO_MODE_F dll

* Bump the ros3 VFD cache to 16 MiB (#3759)

* Fix hangs during collective I/O with independent metadata writes (#3693)

* Fix some issues with collective metadata reads for chunked datasets (#3716)

Add functions/callbacks for explicit control over chunk index open/close

Add functions/callbacks to check if chunk index is open or not so
that it can be opened if necessary before temporarily disabling
collective metadata reads in the library

Add functions/callbacks for requesting loading of additional chunk
index metadata beyond the chunk index itself

* Fix failure in t_select_io_dset when run with more than 10 ranks (#3758)

* Fix H5Pset_evict_on_close failing regardless of actual parallel use (#3761)

Allow H5Pset_evict_on_close to be called regardless of whether a parallel build of HDF5 is being used

Fail during file opens if H5Pset_evict_on_close has been set to true on the given File Access Property List and the size of the MPI communicator being used is greater than 1

1 files changed, 268 insertions, 174 deletions

diff --git a/src/H5Dbtree.c b/src/H5Dbtree.c
index d79f7d0..4f8a867 100644
--- a/src/H5Dbtree.c
+++ b/src/H5Dbtree.c
@@ -24,30 +24,32 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"   /* Generic Functions			*/
-#include "H5Bprivate.h"  /* B-link trees				*/
-#include "H5Dpkg.h"      /* Datasets				*/
-#include "H5Eprivate.h"  /* Error handling		  	*/
-#include "H5Fprivate.h"  /* Files				*/
-#include "H5FDprivate.h" /* File drivers				*/
+#include "H5private.h"   /* Generic Functions                    */
+#include "H5Bprivate.h"  /* B-link trees                         */
+#include "H5Dpkg.h"      /* Datasets                             */
+#include "H5Eprivate.h"  /* Error handling                       */
+#include "H5Fprivate.h"  /* Files                                */
+#include "H5FDprivate.h" /* File drivers                         */
 #include "H5FLprivate.h" /* Free Lists                           */
-#include "H5Iprivate.h"  /* IDs			  		*/
-#include "H5MFprivate.h" /* File space management		*/
-#include "H5MMprivate.h" /* Memory management			*/
-#include "H5Oprivate.h"  /* Object headers		  	*/
+#include "H5Iprivate.h"  /* IDs                                  */
+#include "H5MFprivate.h" /* File space management                */
+#include "H5MMprivate.h" /* Memory management                    */
+#include "H5Oprivate.h"  /* Object headers                       */
 #include "H5Sprivate.h"  /* Dataspaces                           */
-#include "H5VMprivate.h" /* Vector and array functions		*/
+#include "H5VMprivate.h" /* Vector and array functions           */
 
 /****************/
 /* Local Macros */
 /****************/
 
+#define H5D_BTREE_IDX_IS_OPEN(idx_info) (NULL != (idx_info)->storage->u.btree.shared)
+
 /******************/
 /* Local Typedefs */
 /******************/
 
 /*
- * B-tree key.	A key contains the minimum logical N-dimensional coordinates and
+ * B-tree key.  A key contains the minimum logical N-dimensional coordinates and
  * the logical size of the chunk to which this key refers.  The
  * fastest-varying dimension is assumed to reference individual bytes of the
  * array, so a 100-element 1-d array of 4-byte integers would really be a 2-d
@@ -61,9 +63,9 @@
  * The chunk's file address is part of the B-tree and not part of the key.
  */
 typedef struct H5D_btree_key_t {
-    hsize_t  scaled[H5O_LAYOUT_NDIMS]; /*logical offset to start*/
-    uint32_t nbytes;                   /*size of stored data	*/
-    unsigned filter_mask;              /*excluded filters	*/
+    hsize_t  scaled[H5O_LAYOUT_NDIMS]; /*logical offset to start */
+    uint32_t nbytes;                   /*size of stored data */
+    unsigned filter_mask;              /*excluded filters */
 } H5D_btree_key_t;
 
 /* B-tree callback info for iteration over chunks */
@@ -111,10 +113,14 @@ static herr_t H5D__btree_debug_key(FILE *stream, int indent, int fwidth, const v
 static herr_t H5D__btree_idx_init(const H5D_chk_idx_info_t *idx_info, const H5S_t *space,
                                   haddr_t dset_ohdr_addr);
 static herr_t H5D__btree_idx_create(const H5D_chk_idx_info_t *idx_info);
+static herr_t H5D__btree_idx_open(const H5D_chk_idx_info_t *idx_info);
+static herr_t H5D__btree_idx_close(const H5D_chk_idx_info_t *idx_info);
+static herr_t H5D__btree_idx_is_open(const H5D_chk_idx_info_t *idx_info, bool *is_open);
 static bool   H5D__btree_idx_is_space_alloc(const H5O_storage_chunk_t *storage);
 static herr_t H5D__btree_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata,
                                     const H5D_t *dset);
 static herr_t H5D__btree_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata);
+static herr_t H5D__btree_idx_load_metadata(const H5D_chk_idx_info_t *idx_info);
 static int    H5D__btree_idx_iterate(const H5D_chk_idx_info_t *idx_info, H5D_chunk_cb_func_t chunk_cb,
                                      void *chunk_udata);
 static herr_t H5D__btree_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t *udata);
@@ -137,9 +143,13 @@ const H5D_chunk_ops_t H5D_COPS_BTREE[1] = {{
     false,                         /* v1 B-tree indices does not support SWMR access */
     H5D__btree_idx_init,           /* insert */
     H5D__btree_idx_create,         /* create */
+    H5D__btree_idx_open,           /* open */
+    H5D__btree_idx_close,          /* close */
+    H5D__btree_idx_is_open,        /* is_open */
     H5D__btree_idx_is_space_alloc, /* is_space_alloc */
     H5D__btree_idx_insert,         /* insert */
     H5D__btree_idx_get_addr,       /* get_addr */
+    H5D__btree_idx_load_metadata,  /* load_metadata */
     NULL,                          /* resize */
     H5D__btree_idx_iterate,        /* iterate */
     H5D__btree_idx_remove,         /* remove */
@@ -158,21 +168,21 @@ const H5D_chunk_ops_t H5D_COPS_BTREE[1] = {{
 
 /* inherits B-tree like properties from H5B */
 static H5B_class_t H5B_BTREE[1] = {{
-    H5B_CHUNK_ID,            /*id			*/
-    sizeof(H5D_btree_key_t), /*sizeof_nkey		*/
-    H5D__btree_get_shared,   /*get_shared		*/
-    H5D__btree_new_node,     /*new			*/
-    H5D__btree_cmp2,         /*cmp2			*/
-    H5D__btree_cmp3,         /*cmp3			*/
-    H5D__btree_found,        /*found			*/
-    H5D__btree_insert,       /*insert		*/
-    false,                   /*follow min branch?	*/
-    false,                   /*follow max branch?	*/
-    H5B_LEFT,                /*critical key          */
-    H5D__btree_remove,       /*remove		*/
-    H5D__btree_decode_key,   /*decode		*/
-    H5D__btree_encode_key,   /*encode		*/
-    H5D__btree_debug_key     /*debug			*/
+    H5B_CHUNK_ID,            /* id */
+    sizeof(H5D_btree_key_t), /* sizeof_nkey */
+    H5D__btree_get_shared,   /* get_shared */
+    H5D__btree_new_node,     /* new */
+    H5D__btree_cmp2,         /* cmp2 */
+    H5D__btree_cmp3,         /* cmp3 */
+    H5D__btree_found,        /* found */
+    H5D__btree_insert,       /* insert */
+    false,                   /* follow min branch? */
+    false,                   /* follow max branch? */
+    H5B_LEFT,                /* critical key */
+    H5D__btree_remove,       /* remove */
+    H5D__btree_decode_key,   /* decode */
+    H5D__btree_encode_key,   /* encode */
+    H5D__btree_debug_key     /* debug */
 }};
 
 /*******************/
@@ -183,13 +193,13 @@ static H5B_class_t H5B_BTREE[1] = {{
 H5FL_DEFINE_STATIC(H5O_layout_chunk_t);
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_get_shared
+ * Function:    H5D__btree_get_shared
  *
- * Purpose:	Returns the shared B-tree info for the specified UDATA.
+ * Purpose:     Returns the shared B-tree info for the specified UDATA.
  *
- * Return:	Success:	Pointer to the raw B-tree page for this dataset
+ * Return:      Success:    Pointer to the raw B-tree page for this dataset
  *
- *		Failure:	Can't fail
+ *              Failure:    Can't fail
  *
  *-------------------------------------------------------------------------
  */
@@ -210,17 +220,17 @@ H5D__btree_get_shared(const H5F_t H5_ATTR_UNUSED *f, const void *_udata)
 } /* end H5D__btree_get_shared() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_new_node
+ * Function:    H5D__btree_new_node
  *
- * Purpose:	Adds a new entry to an i-storage B-tree.  We can assume that
- *		the domain represented by UDATA doesn't intersect the domain
- *		already represented by the B-tree.
+ * Purpose:     Adds a new entry to an i-storage B-tree.  We can assume
+ *              that the domain represented by UDATA doesn't intersect the
+ *              domain already represented by the B-tree.
  *
- * Return:	Success:	Non-negative. The address of leaf is returned
- *				through the ADDR argument.  It is also added
- *				to the UDATA.
+ * Return:      Success:    Non-negative. The address of leaf is returned
+ *                          through the ADDR argument.  It is also added
+ *                          to the UDATA.
  *
- * 		Failure:	Negative
+ *              Failure:    Negative
  *
  *-------------------------------------------------------------------------
  */
@@ -275,18 +285,18 @@ H5D__btree_new_node(H5F_t H5_ATTR_NDEBUG_UNUSED *f, H5B_ins_t op, void *_lt_key,
 } /* end H5D__btree_new_node() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_cmp2
+ * Function:    H5D__btree_cmp2
  *
- * Purpose:	Compares two keys sort of like strcmp().  The UDATA pointer
- *		is only to supply extra information not carried in the keys
- *		(in this case, the dimensionality) and is not compared
- *		against the keys.
+ * Purpose:     Compares two keys sort of like strcmp().  The UDATA pointer
+ *              is only to supply extra information not carried in the keys
+ *              (in this case, the dimensionality) and is not compared
+ *              against the keys.
  *
- * Return:	Success:	-1 if LT_KEY is less than RT_KEY;
- *				1 if LT_KEY is greater than RT_KEY;
- *				0 if LT_KEY and RT_KEY are equal.
+ * Return:      Success:    -1 if LT_KEY is less than RT_KEY;
+ *                          1 if LT_KEY is greater than RT_KEY;
+ *                          0 if LT_KEY and RT_KEY are equal.
  *
- *		Failure:	FAIL (same as LT_KEY<RT_KEY)
+ *              Failure:    FAIL (same as LT_KEY < RT_KEY)
  *
  *-------------------------------------------------------------------------
  */
@@ -312,26 +322,26 @@ H5D__btree_cmp2(void *_lt_key, void *_udata, void *_rt_key)
 } /* end H5D__btree_cmp2() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_cmp3
+ * Function:    H5D__btree_cmp3
  *
- * Purpose:	Compare the requested datum UDATA with the left and right
- *		keys of the B-tree.
+ * Purpose:     Compare the requested datum UDATA with the left and right
+ *              keys of the B-tree.
  *
- * Return:	Success:	negative if the min_corner of UDATA is less
- *				than the min_corner of LT_KEY.
+ * Return:      Success:    negative if the min_corner of UDATA is less
+ *                          than the min_corner of LT_KEY.
  *
- *				positive if the min_corner of UDATA is
- *				greater than or equal the min_corner of
- *				RT_KEY.
+ *                          positive if the min_corner of UDATA is
+ *                          greater than or equal the min_corner of
+ *                          RT_KEY.
  *
- *				zero otherwise.	 The min_corner of UDATA is
- *				not necessarily contained within the address
- *				space represented by LT_KEY, but a key that
- *				would describe the UDATA min_corner address
- *				would fall lexicographically between LT_KEY
- *				and RT_KEY.
+ *                          zero otherwise.  The min_corner of UDATA is
+ *                          not necessarily contained within the address
+ *                          space represented by LT_KEY, but a key that
+ *                          would describe the UDATA min_corner address
+ *                          would fall lexicographically between LT_KEY
+ *                          and RT_KEY.
  *
- *		Failure:	FAIL (same as UDATA < LT_KEY)
+ *              Failure:    FAIL (same as UDATA < LT_KEY)
  *
  *-------------------------------------------------------------------------
  */
@@ -375,23 +385,24 @@ H5D__btree_cmp3(void *_lt_key, void *_udata, void *_rt_key)
 } /* end H5D__btree_cmp3() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_found
- *
- * Purpose:	This function is called when the B-tree search engine has
- *		found the leaf entry that points to a chunk of storage that
- *		contains the beginning of the logical address space
- *		represented by UDATA.  The LT_KEY is the left key (the one
- *		that describes the chunk) and RT_KEY is the right key (the
- *		one that describes the next or last chunk).
- *
- * Note:	It's possible that the chunk isn't really found.  For
- *		instance, in a sparse dataset the requested chunk might fall
- *		between two stored chunks in which case this function is
- *		called with the maximum stored chunk indices less than the
- *		requested chunk indices.
- *
- * Return:	Non-negative on success with information about the
- *              chunk returned through the UDATA argument, if *FOUND is true.
+ * Function:    H5D__btree_found
+ *
+ * Purpose:     This function is called when the B-tree search engine has
+ *              found the leaf entry that points to a chunk of storage that
+ *              contains the beginning of the logical address space
+ *              represented by UDATA.  The LT_KEY is the left key (the one
+ *              that describes the chunk) and RT_KEY is the right key (the
+ *              one that describes the next or last chunk).
+ *
+ * Note:        It's possible that the chunk isn't really found.  For
+ *              instance, in a sparse dataset the requested chunk might fall
+ *              between two stored chunks in which case this function is
+ *              called with the maximum stored chunk indices less than the
+ *              requested chunk indices.
+ *
+ * Return:      Non-negative on success with information about the
+ *              chunk returned through the UDATA argument, if *FOUND is
+ *              true.
  *              Negative on failure.
  *
  *-------------------------------------------------------------------------
@@ -432,14 +443,14 @@ done:
 } /* end H5D__btree_found() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__chunk_disjoint
+ * Function:    H5D__chunk_disjoint
  *
- * Purpose:	Determines if two chunks are disjoint.
+ * Purpose:     Determines if two chunks are disjoint.
  *
- * Return:	Success:	false if they are not disjoint.
- *				true if they are disjoint.
+ * Return:      Success:    false if they are not disjoint.
+ *                          true if they are disjoint.
  *
- * Note:	Assumes that the chunk offsets are scaled coordinates
+ * Note:        Assumes that the chunk offsets are scaled coordinates
  *
  *-------------------------------------------------------------------------
  */
@@ -466,27 +477,27 @@ done:
 } /* end H5D__chunk_disjoint() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_insert
+ * Function:    H5D__btree_insert
  *
- * Purpose:	This function is called when the B-tree insert engine finds
- *		the node to use to insert new data.  The UDATA argument
- *		points to a struct that describes the logical addresses being
- *		added to the file.  This function allocates space for the
- *		data and returns information through UDATA describing a
- *		file chunk to receive (part of) the data.
+ * Purpose:     This function is called when the B-tree insert engine finds
+ *              the node to use to insert new data.  The UDATA argument
+ *              points to a struct that describes the logical addresses being
+ *              added to the file.  This function allocates space for the
+ *              data and returns information through UDATA describing a
+ *              file chunk to receive (part of) the data.
  *
- *		The LT_KEY is always the key describing the chunk of file
- *		memory at address ADDR. On entry, UDATA describes the logical
- *		addresses for which storage is being requested (through the
- *		`offset' and `size' fields). On return, UDATA describes the
- *		logical addresses contained in a chunk on disk.
+ *              The LT_KEY is always the key describing the chunk of file
+ *              memory at address ADDR. On entry, UDATA describes the logical
+ *              addresses for which storage is being requested (through the
+ *              `offset' and `size' fields). On return, UDATA describes the
+ *              logical addresses contained in a chunk on disk.
  *
- * Return:	Success:	An insertion command for the caller, one of
- *				the H5B_INS_* constants.  The address of the
- *				new chunk is returned through the NEW_NODE
- *				argument.
+ * Return:      Success:    An insertion command for the caller, one of
+ *                          the H5B_INS_* constants.  The address of the
+ *                          new chunk is returned through the NEW_NODE
+ *                          argument.
  *
- *		Failure:	H5B_INS_ERROR
+ *              Failure:    H5B_INS_ERROR
  *
  *-------------------------------------------------------------------------
  */
@@ -567,11 +578,11 @@ done:
 } /* end H5D__btree_insert() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_remove
+ * Function:    H5D__btree_remove
  *
- * Purpose:	Removes chunks that are no longer necessary in the B-tree.
+ * Purpose:     Removes chunks that are no longer necessary in the B-tree.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -645,11 +656,11 @@ done:
 } /* end H5D__btree_decode_key() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_encode_key
+ * Function:    H5D__btree_encode_key
  *
- * Purpose:	Encode a key from native format to raw format.
+ * Purpose:     Encode a key from native format to raw format.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -684,11 +695,11 @@ H5D__btree_encode_key(const H5B_shared_t *shared, uint8_t *raw, const void *_key
 } /* end H5D__btree_encode_key() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_debug_key
+ * Function:    H5D__btree_debug_key
  *
- * Purpose:	Prints a key.
+ * Purpose:     Prints a key.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -714,11 +725,11 @@ H5D__btree_debug_key(FILE *stream, int indent, int fwidth, const void *_key, con
 } /* end H5D__btree_debug_key() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_shared_free
+ * Function:    H5D__btree_shared_free
  *
- * Purpose:	Free "local" B-tree shared info
+ * Purpose:     Free "local" B-tree shared info
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -742,11 +753,11 @@ done:
 } /* end H5D__btree_shared_free() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_shared_create
+ * Function:    H5D__btree_shared_create
  *
- * Purpose:	Create & initialize B-tree shared info
+ * Purpose:     Create & initialize B-tree shared info
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -788,11 +799,11 @@ done:
 } /* end H5D__btree_shared_create() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_init
+ * Function:    H5D__btree_idx_init
  *
- * Purpose:	Initialize the indexing information for a dataset.
+ * Purpose:     Initialize the indexing information for a dataset.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -823,17 +834,18 @@ done:
 } /* end H5D__btree_idx_init() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_create
+ * Function:    H5D__btree_idx_create
  *
- * Purpose:	Creates a new indexed-storage B-tree and initializes the
- *		layout struct with information about the storage.  The
- *		struct should be immediately written to the object header.
+ * Purpose:     Creates a new indexed-storage B-tree and initializes the
+ *              layout struct with information about the storage.  The
+ *              struct should be immediately written to the object header.
  *
- *		This function must be called before passing LAYOUT to any of
- *		the other indexed storage functions!
+ *              This function must be called before passing LAYOUT to any
+ *              of the other indexed storage functions!
  *
- * Return:	Non-negative on success (with the LAYOUT argument initialized
- *		and ready to write to an object header). Negative on failure.
+ * Return:      Non-negative on success (with the LAYOUT argument
+ *              initialized and ready to write to an object header).
+ *              Negative on failure.
  *
  *-------------------------------------------------------------------------
  */
@@ -866,11 +878,73 @@ done:
 } /* end H5D__btree_idx_create() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_is_space_alloc
+ * Function:    H5D__btree_idx_open
+ *
+ * Purpose:     Opens an existing B-tree. Currently a no-op.
+ *
+ * Return:      SUCCEED (can't fail)
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D__btree_idx_open(const H5D_chk_idx_info_t H5_ATTR_UNUSED *idx_info)
+{
+    FUNC_ENTER_PACKAGE_NOERR
+
+    /* NO OP */
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5D__btree_idx_open() */
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__btree_idx_close
  *
- * Purpose:	Query if space is allocated for index method
+ * Purpose:     Closes an existing B-tree. Currently a no-op.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED (can't fail)
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D__btree_idx_close(const H5D_chk_idx_info_t H5_ATTR_UNUSED *idx_info)
+{
+    FUNC_ENTER_PACKAGE_NOERR
+
+    /* NO OP */
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5D__btree_idx_close() */
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__btree_idx_is_open
+ *
+ * Purpose:     Query if the index is opened or not
+ *
+ * Return:      SUCCEED (can't fail)
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D__btree_idx_is_open(const H5D_chk_idx_info_t *idx_info, bool *is_open)
+{
+    FUNC_ENTER_PACKAGE_NOERR
+
+    assert(idx_info);
+    assert(idx_info->storage);
+    assert(H5D_CHUNK_IDX_BTREE == idx_info->storage->idx_type);
+    assert(is_open);
+
+    *is_open = H5D_BTREE_IDX_IS_OPEN(idx_info);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5D__btree_idx_is_open() */
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__btree_idx_is_space_alloc
+ *
+ * Purpose:     Query if space is allocated for index method
+ *
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -886,11 +960,11 @@ H5D__btree_idx_is_space_alloc(const H5O_storage_chunk_t *storage)
 } /* end H5D__btree_idx_is_space_alloc() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_insert
+ * Function:    H5D__btree_idx_insert
  *
- * Purpose:	Insert chunk entry into the indexing structure.
+ * Purpose:     Insert chunk entry into the indexing structure.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -922,13 +996,13 @@ done:
 } /* H5D__btree_idx_insert() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_get_addr
+ * Function:    H5D__btree_idx_get_addr
  *
- * Purpose:	Get the file address of a chunk if file space has been
- *		assigned.  Save the retrieved information in the udata
- *		supplied.
+ * Purpose:     Get the file address of a chunk if file space has been
+ *              assigned.  Save the retrieved information in the udata
+ *              supplied.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -959,14 +1033,34 @@ done:
 } /* H5D__btree_idx_get_addr() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_iterate_cb
+ * Function:    H5D__btree_idx_load_metadata
+ *
+ * Purpose:     Load additional chunk index metadata beyond the chunk index
+ *              itself. Currently a no-op.
+ *
+ * Return:      Non-negative on success/Negative on failure
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D__btree_idx_load_metadata(const H5D_chk_idx_info_t H5_ATTR_UNUSED *idx_info)
+{
+    FUNC_ENTER_PACKAGE_NOERR
+
+    /* NO OP */
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5D__btree_idx_load_metadata() */
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__btree_idx_iterate_cb
  *
- * Purpose:	Translate the B-tree specific chunk record into a generic
+ * Purpose:     Translate the B-tree specific chunk record into a generic
  *              form and make the callback to the generic chunk callback
  *              routine.
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      Success:    Non-negative
+ *              Failure:    Negative
  *
  *-------------------------------------------------------------------------
  */
@@ -1001,12 +1095,12 @@ H5D__btree_idx_iterate_cb(H5F_t H5_ATTR_UNUSED *f, const void *_lt_key, haddr_t
 } /* H5D__btree_idx_iterate_cb() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_iterate
+ * Function:    H5D__btree_idx_iterate
  *
- * Purpose:	Iterate over the chunks in an index, making a callback
+ * Purpose:     Iterate over the chunks in an index, making a callback
  *              for each one.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -1043,11 +1137,11 @@ H5D__btree_idx_iterate(const H5D_chk_idx_info_t *idx_info, H5D_chunk_cb_func_t c
 } /* end H5D__btree_idx_iterate() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_remove
+ * Function:    H5D__btree_idx_remove
  *
- * Purpose:	Remove chunk from index.
+ * Purpose:     Remove chunk from index.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -1077,13 +1171,13 @@ done:
 } /* H5D__btree_idx_remove() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_delete
+ * Function:    H5D__btree_idx_delete
  *
- * Purpose:	Delete index and raw data storage for entire dataset
+ * Purpose:     Delete index and raw data storage for entire dataset
  *              (i.e. all chunks)
  *
- * Return:	Success:	Non-negative
- *		Failure:	negative
+ * Return:      Success:    Non-negative
+ *              Failure:    negative
  *
  *-------------------------------------------------------------------------
  */
@@ -1134,11 +1228,11 @@ done:
 } /* end H5D__btree_idx_delete() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_copy_setup
+ * Function:    H5D__btree_idx_copy_setup
  *
- * Purpose:	Set up any necessary information for copying chunks
+ * Purpose:     Set up any necessary information for copying chunks
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -1178,11 +1272,11 @@ done:
 } /* end H5D__btree_idx_copy_setup() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_copy_shutdown
+ * Function:    H5D__btree_idx_copy_shutdown
  *
- * Purpose:	Shutdown any information from copying chunks
+ * Purpose:     Shutdown any information from copying chunks
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -1250,11 +1344,11 @@ done:
 } /* end H5D__btree_idx_size() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_reset
+ * Function:    H5D__btree_idx_reset
  *
- * Purpose:	Reset indexing information.
+ * Purpose:     Reset indexing information.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -1274,11 +1368,11 @@ H5D__btree_idx_reset(H5O_storage_chunk_t *storage, bool reset_addr)
 } /* end H5D__btree_idx_reset() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_dump
+ * Function:    H5D__btree_idx_dump
  *
- * Purpose:	Dump indexing information to a stream.
+ * Purpose:     Dump indexing information to a stream.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -1296,11 +1390,11 @@ H5D__btree_idx_dump(const H5O_storage_chunk_t *storage, FILE *stream)
 } /* end H5D__btree_idx_dump() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__btree_idx_dest
+ * Function:    H5D__btree_idx_dest
  *
- * Purpose:	Release indexing information in memory.
+ * Purpose:     Release indexing information in memory.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
@@ -1328,11 +1422,11 @@ done:
 } /* end H5D__btree_idx_dest() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5D_btree_debug
+ * Function:    H5D_btree_debug
  *
- * Purpose:	Debugs a B-tree node for indexed raw data storage.
+ * Purpose:     Debugs a B-tree node for indexed raw data storage.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */