HDFFV-10677 and HDFFV-10661

Description:
    - Added functions to query chunk information:
        H5Dget_num_chunks(dset_id, fspace_id, *nchunks)
            Gets the number of written chunks that intersect with the given
            dataspace.  However, in this version, the intersection is not
            yet completed.  Thus, the number of all written chunks will be
            returned.
        H5Dget_chunk_info_by_coord(dset_id, *offset, *filter_mask, *addr, *size)
            Given a chunk's logical coordinates, returns the chunk's filter,
            address, and size.
        H5Dget_chunk_info(dset_id, fspace_id, index, *offset, *filter_mask, *addr, *size)
            Given a chunk's index, returns the chunk's logical coordinates, filter,
            address, and size.  The chunk belongs to a set of chunks that have
            nonempty intersection with the specified dataspace.  However, in
            this version, the intersection is not yet completed, and the index
            is of all the written chunks.
        These functions comply with VOL.

    - Fixed some oversights found in the library for the tests in chunk_info.c
      to work correctly.  The returned value from a callback function was not
      checked in H5EA_iterate(), H5FA_iterate(), and H5D__none_idx_iterate().
      This oversight caused a callback function to continue iterating even though
      it's supposed to stop.
Platforms tested:
    Linux/64 (jelly)
    Linux/64 (platypus)
    Darwin (osx1011test)

9 files changed, 707 insertions, 64 deletions

diff --git a/src/H5D.c b/src/H5D.c
index a8cefd9..9c3a096 100644
--- a/src/H5D.c
+++ b/src/H5D.c
@@ -457,8 +457,8 @@ done:
  *
  *              Failure:    H5I_INVALID_HID
  *
- * Programmer:	Robb Matzke
- *		Tuesday, February  3, 1998
+ * Programmer:  Robb Matzke
+ *              Tuesday, February  3, 1998
  *
  *-------------------------------------------------------------------------
  */
@@ -512,8 +512,8 @@ done:
  *
  *              Failure:    H5I_INVALID_HID
  *
- * Programmer:	Neil Fortner
- *		Wednesday, October 29, 2008
+ * Programmer:  Neil Fortner
+ *              Wednesday, October 29, 2008
  *
  *-------------------------------------------------------------------------
  */
@@ -610,9 +610,9 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Diterate
+ * Function:    H5Diterate
  *
- * Purpose:	This routine iterates over all the elements selected in a memory
+ * Purpose: This routine iterates over all the elements selected in a memory
  *      buffer.  The callback function is called once for each element selected
  *      in the dataspace.  The selection in the dataspace is modified so
  *      that any elements already iterated over are removed from the selection
@@ -659,11 +659,11 @@ done:
  *              indicating failure. The iterator can be restarted at the next
  *              element.
  *
- * Return:	Returns the return value of the last operator if it was non-zero,
+ * Return:  Returns the return value of the last operator if it was non-zero,
  *          or zero if all elements were processed. Otherwise returns a
  *          negative value.
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Friday, June 11, 1999
  *
  *-------------------------------------------------------------------------
@@ -706,16 +706,16 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dvlen_reclaim
+ * Function:    H5Dvlen_reclaim
  *
- * Purpose:	Frees the buffers allocated for storing variable-length data
+ * Purpose: Frees the buffers allocated for storing variable-length data
  *      in memory.  Only frees the VL data in the selection defined in the
  *      dataspace.  The dataset transfer property list is required to find the
  *      correct allocation/free methods for the VL data in the buffer.
  *
- * Return:	Non-negative on success, negative on failure
+ * Return:  Non-negative on success, negative on failure
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, June 10, 1999
  *
  *-------------------------------------------------------------------------
@@ -756,9 +756,9 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dvlen_get_buf_size
+ * Function:    H5Dvlen_get_buf_size
  *
- * Purpose:	This routine checks the number of bytes required to store the VL
+ * Purpose: This routine checks the number of bytes required to store the VL
  *      data from the dataset, using the space_id for the selection in the
  *      dataset on disk and the type_id for the memory representation of the
  *      VL data, in memory.  The *size value is modified according to how many
@@ -772,9 +772,9 @@ done:
  *      Kinda kludgy, but easier than the other method of trying to figure out
  *      the sizes without actually reading the data in... - QAK
  *
- * Return:	Non-negative on success, negative on failure
+ * Return:  Non-negative on success, negative on failure
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Wednesday, August 11, 1999
  *
  *-------------------------------------------------------------------------
@@ -1095,3 +1095,150 @@ done:
     FUNC_LEAVE_API(ret_value);
 } /* H5Dget_chunk_storage_size() */
 
+
+/*-------------------------------------------------------------------------
+ * Function:    H5Dget_num_chunks
+ *
+ * Purpose:     Retrieves the number of chunks that have non-empty intersection
+ *              with a specified selection.
+ *
+ * Note:        Currently, this function only gets the number of all written
+ *              chunks, regardless the dataspace.
+ *
+ * Parameters:
+ *              hid_t dset_id;      IN: Chunked dataset ID
+ *              hid_t fspace_id;    IN: File dataspace ID
+ *              hsize_t *nchunks;   OUT: Number of non-empty chunks
+ *
+ * Return:      Non-negative on success, negative on failure
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              May 2019 (HDFFV-10677)
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Dget_num_chunks(hid_t dset_id, hid_t fspace_id, hsize_t *nchunks)
+{
+    H5VL_object_t  *vol_obj = NULL;     /* Dataset for this operation */
+    herr_t          ret_value = SUCCEED;
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE3("e", "ii*h", dset_id, fspace_id, nchunks);
+
+    /* Check arguments */
+    if(NULL == (vol_obj = (H5VL_object_t *)H5I_object_verify(dset_id, H5I_DATASET)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid dataset identifier")
+    if(NULL == nchunks)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid argument (null)")
+
+    /* Get the number of written chunks */
+    if(H5VL_dataset_optional(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL, H5VL_NATIVE_DATASET_GET_NUM_CHUNKS, fspace_id, nchunks) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "Can't get number of chunks")
+
+done:
+    FUNC_LEAVE_API(ret_value);
+} /* H5Dget_num_chunks() */
+ 
+
+/*-------------------------------------------------------------------------
+ * Function:    H5Dget_chunk_info
+ *
+ * Purpose:     Retrieves information about a chunk specified by its index.
+ *
+ * Parameters:
+ *              hid_t dset_id;          IN: Chunked dataset ID
+ *              hid_t fspace_id;        IN: File dataspace ID
+ *              hsize_t index;          IN: Index of written chunk
+ *              hsize_t *offset         OUT: Logical position of the chunk’s
+ *                                           first element in the dataspace
+ *              unsigned *filter_mask   OUT: Mask for identifying the filters in use
+ *              haddr_t *addr           OUT: Address of the chunk
+ *              hsize_t *size           OUT: Size of the chunk
+ *
+ * Return:      Non-negative on success, negative on failure
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              May 2019 (HDFFV-10677)
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Dget_chunk_info(hid_t dset_id, hid_t fspace_id, hsize_t chk_index, hsize_t *offset, unsigned *filter_mask, haddr_t *addr, hsize_t *size)
+{
+    H5VL_object_t *vol_obj = NULL;     /* Dataset for this operation */
+    hsize_t        nchunks= 0;
+    herr_t         ret_value = SUCCEED;
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE7("e", "iih*h*Iu*a*h", dset_id, fspace_id, chk_index, offset,
+             filter_mask, addr, size);
+
+    /* Check arguments */
+    if(NULL == offset && NULL == filter_mask && NULL == addr && NULL == size)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid arguments, must have at least one non-null output argument")
+    if(NULL == (vol_obj = (H5VL_object_t *)H5I_object_verify(dset_id, H5I_DATASET)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid dataset identifier")
+
+    /* Get the number of written chunks to check range */
+    if(H5VL_dataset_optional(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL, H5VL_NATIVE_DATASET_GET_NUM_CHUNKS, fspace_id, &nchunks) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "Can't get number of chunks")
+
+    /* Check range for chunk index */
+    if(chk_index >= nchunks)
+        HGOTO_ERROR(H5E_IO, H5E_BADRANGE, FAIL, "chunk index is out of range")
+
+    /* Call private function to get the chunk info given the chunk's index */
+    if(H5VL_dataset_optional(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL, H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_IDX, fspace_id, chk_index, offset, filter_mask, addr, size) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "Can't get chunk info by index")
+
+done:
+    FUNC_LEAVE_API(ret_value);
+} /* H5Dget_chunk_info() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5Dget_chunk_info_by_coord
+ *
+ * Purpose:     Retrieves information about a chunk specified by its logical
+ *              coordinates.
+ *
+ * Parameters:
+ *              hid_t dset_id;          IN: Chunked dataset ID
+ *              hsize_t *offset         IN: Logical position of the chunk’s
+ *                                           first element in the dataspace
+ *              unsigned *filter_mask   OUT: Mask for identifying the filters in use
+ *              haddr_t *addr           OUT: Address of the chunk
+ *              hsize_t *size           OUT: Size of the chunk
+ *
+ * Return:      Non-negative on success, negative on failure
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              May 2019 (HDFFV-10677)
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Dget_chunk_info_by_coord(hid_t dset_id, const hsize_t *offset, unsigned *filter_mask, haddr_t *addr, hsize_t *size)
+{
+    H5VL_object_t  *vol_obj = NULL;     /* Dataset for this operation */
+    herr_t          ret_value = SUCCEED;
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE5("e", "i*h*Iu*a*h", dset_id, offset, filter_mask, addr, size);
+
+    /* Check arguments */
+    if(NULL == (vol_obj = (H5VL_object_t *)H5I_object_verify(dset_id, H5I_DATASET)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid dataset identifier")
+    if(NULL == filter_mask && NULL == addr && NULL == size)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid arguments, must have at least one non-null output argument")
+    if(NULL == offset)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid argument (null)")
+
+    /* Call private function to get the chunk info given the chunk's index */
+    if(H5VL_dataset_optional(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL, H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_COOR, offset, filter_mask, addr, size) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "Can't get chunk info by its logical coordinates")
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* end H5Dget_chunk_info_by_coord() */
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 082aac3..4976075 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -216,6 +216,18 @@ typedef struct H5D_chunk_readvv_ud_t {
     const H5D_t *dset;          /* Dataset to operate on */
 } H5D_chunk_readvv_ud_t;
 
+typedef struct H5D_chunk_info_iter_ud_t {
+    hsize_t  scaled[H5O_LAYOUT_NDIMS];    /* Logical offset of the chunk */
+    hsize_t  ndims;             /* Number of dimensions in the dataset */
+    uint32_t nbytes;            /* Size of stored data in the chunk */
+    unsigned filter_mask;       /* Excluded filters */
+    haddr_t  chunk_addr;        /* Address of the chunk in file */
+    hsize_t  chunk_idx;         /* Chunk index, where the iteration needs to stop */
+    hsize_t  curr_idx;          /* Current index, where the iteration is */
+    unsigned idx_hint;          /* Index of chunk in cache, if present */
+    hbool_t  found;             /* Whether the chunk was found */
+} H5D_chunk_info_iter_ud_t;
+
 /* Callback info for file selection iteration */
 typedef struct H5D_chunk_file_iter_ud_t {
     H5D_chunk_map_t *fm;                /* File->memory chunk mapping info */
@@ -252,6 +264,11 @@ static herr_t H5D__chunk_flush(H5D_t *dset);
 static herr_t H5D__chunk_io_term(const H5D_chunk_map_t *fm);
 static herr_t H5D__chunk_dest(H5D_t *dset);
 
+/* Chunk query operation callbacks */
+static int H5D__get_num_chunks_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata);
+static int H5D__get_chunk_info_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata);
+static int H5D__get_chunk_info_by_coord_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata);
+
 /* "Nonexistent" layout operation callback */
 static ssize_t
 H5D__nonexistent_readvv(const H5D_io_info_t *io_info,
@@ -6956,3 +6973,378 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__chunk_format_convert() */
 
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__get_num_chunks_cb
+ *
+ * Purpose:     Callback function that increments the number of written
+ *              chunks in the dataset.
+ *
+ * Note:        Currently, this function only gets the number of all written
+ *              chunks, regardless the dataspace.
+ *
+ * Return:      H5_ITER_CONT
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              June 2019 (HDFFV-10677)
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+H5D__get_num_chunks_cb(const H5D_chunk_rec_t H5_ATTR_UNUSED *chunk_rec, void *_udata)
+{
+    hsize_t *num_chunks = (hsize_t *)_udata;
+    int ret_value = H5_ITER_CONT;         /* Callback return value */
+
+    FUNC_ENTER_STATIC_NOERR
+
+    HDassert(num_chunks);
+
+    (*num_chunks)++;
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D__get_num_chunks_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__get_num_chunks
+ *
+ * Purpose:     Gets the number of written chunks in a dataset.
+ *
+ * Note:        Currently, this function only gets the number of all written
+ *              chunks, regardless the dataspace.
+ *
+ * Return:      Success:    Non-negative
+ *              Failure:    Negative
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              June 2019 (HDFFV-10677)
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5D__get_num_chunks(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_t *nchunks)
+{
+    H5D_chk_idx_info_t idx_info;                /* Chunked index info */
+    hsize_t            num_chunks = 0;          /* Number of written chunks */
+    H5D_rdcc_ent_t     *ent;                    /* Cache entry  */
+    const H5D_rdcc_t   *rdcc = NULL;            /* Raw data chunk cache */
+    const H5O_layout_t *layout;                 /* Dataset layout */
+    herr_t             ret_value = SUCCEED;     /* Return value */
+
+    FUNC_ENTER_PACKAGE_TAG(dset->oloc.addr)
+
+    HDassert(dset);
+    HDassert(dset->shared);
+    HDassert(space);
+    HDassert(nchunks);
+
+    layout = &(dset->shared->layout);    /* Dataset layout */
+    rdcc = &(dset->shared->cache.chunk); /* raw data chunk cache */
+    HDassert(rdcc);
+
+    /* Search for cached chunks that haven't been written out */
+    for(ent = rdcc->head; ent; ent = ent->next)
+        /* Flush the chunk out to disk, to make certain the size is correct later */
+        if(H5D__chunk_flush_entry(dset, ent, FALSE) < 0)
+            HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "cannot flush indexed storage buffer")
+
+    /* Compose chunked index info struct */
+    idx_info.f = dset->oloc.file;
+    idx_info.pline = &dset->shared->dcpl_cache.pline;
+    idx_info.layout = &dset->shared->layout.u.chunk;
+    idx_info.storage = &dset->shared->layout.storage.u.chunk;
+
+    /* If the dataset is not written, number of chunks will be 0 */
+    if(!H5F_addr_defined(idx_info.storage->idx_addr)) {
+        *nchunks = 0;
+    }
+    else {
+        /* Iterate over the allocated chunks */
+        if((dset->shared->layout.storage.u.chunk.ops->iterate)(&idx_info, H5D__get_num_chunks_cb, &num_chunks) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve allocated chunk information from index")
+        *nchunks = num_chunks;
+    }
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D__get_num_chunks() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__get_chunk_info_cb
+ *
+ * Purpose:     Get the chunk info of the queried chunk, given by its index.
+ *
+ * Return:      Success:    H5_ITER_CONT or H5_ITER_STOP
+ *                          H5_ITER_STOP indicates the queried chunk is found
+ *              Failure:    Negative (H5_ITER_ERROR)
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              June 2019 (HDFFV-10677)
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+H5D__get_chunk_info_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
+{
+    H5D_chunk_info_iter_ud_t *chunk_info = (H5D_chunk_info_iter_ud_t *)_udata;
+    hsize_t ii = 0;                     /* Dimension index */
+    int     ret_value = H5_ITER_CONT;   /* Callback return value */
+
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Check args */
+    HDassert(chunk_rec);
+    HDassert(chunk_info);
+
+    /* If this is the queried chunk, retrieve its info and stop iterating */
+    if (chunk_info->curr_idx == chunk_info->chunk_idx) {
+        chunk_info->filter_mask = chunk_rec->filter_mask;
+        chunk_info->chunk_addr = chunk_rec->chunk_addr;
+        chunk_info->nbytes = chunk_rec->nbytes;
+        for (ii = 0; ii < chunk_info->ndims; ii++)
+            chunk_info->scaled[ii] = chunk_rec->scaled[ii];
+        chunk_info->found = TRUE;
+
+        /* Stop iterating */
+        ret_value = H5_ITER_STOP;
+    }
+    /* Go to the next chunk */
+    else
+        chunk_info->curr_idx++;
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D__get_chunk_info_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__get_chunk_info
+ *
+ * Purpose:     Iterate over the chunks in the dataset to get the info
+ *              of the desired chunk.
+ *
+ * Note:        Currently, this function only gets the number of all written
+ *              chunks, regardless the dataspace.
+ *
+ * Return:      Success: SUCCEED
+ *              Failure: FAIL
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              June 2019 (HDFFV-10677)
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5D__get_chunk_info(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_t chk_index, hsize_t *offset, unsigned *filter_mask, haddr_t *addr, hsize_t *size)
+{
+    H5D_chk_idx_info_t idx_info;           /* Chunked index info */
+    H5D_chunk_info_iter_ud_t udata;        /* User data for callback */
+    const H5D_rdcc_t   *rdcc = NULL;       /* Raw data chunk cache */
+    H5D_rdcc_ent_t     *ent;               /* Cache entry index */
+    hsize_t            ii = 0;             /* Dimension index */
+    hsize_t            nchunks = 0;        /* Number of chunks in this dset */
+    hsize_t scaled[H5S_MAX_RANK];
+    herr_t             ret_value = SUCCEED;/* Return value */
+
+    FUNC_ENTER_PACKAGE_TAG(dset->oloc.addr)
+
+    HDassert(dset);
+    HDassert(dset->shared);
+    HDassert(space);
+
+    /* Get the raw data chunk cache */
+    rdcc = &(dset->shared->cache.chunk);
+    HDassert(rdcc);
+
+    /* Search for cached chunks that haven't been written out */
+    for(ent = rdcc->head; ent; ent = ent->next)
+        /* Flush the chunk out to disk, to make certain the size is correct later */
+        if(H5D__chunk_flush_entry(dset, ent, FALSE) < 0)
+            HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "cannot flush indexed storage buffer")
+
+    /* Compose chunked index info struct */
+    idx_info.f = dset->oloc.file;
+    idx_info.pline = &dset->shared->dcpl_cache.pline;
+    idx_info.layout = &dset->shared->layout.u.chunk;
+    idx_info.storage = &dset->shared->layout.storage.u.chunk;
+
+    /* Set addr & size for when dset is not written or queried chunk is not found */
+    if (addr)
+        *addr = HADDR_UNDEF;
+    if (size)
+        *size = 0;
+
+    /* If the chunk is written, get its info, otherwise, return without error */
+    if(H5F_addr_defined(idx_info.storage->idx_addr)) {
+        /* Initialize before iteration */
+        udata.chunk_idx = chk_index;
+        udata.curr_idx = 0;
+        udata.ndims = dset->shared->ndims;
+        udata.nbytes = 0;
+        udata.filter_mask = 0;
+        udata.chunk_addr = HADDR_UNDEF;
+        udata.found = FALSE;
+
+        /* Iterate over the allocated chunks */
+        if((dset->shared->layout.storage.u.chunk.ops->iterate)(&idx_info, H5D__get_chunk_info_cb, &udata) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve allocated chunk information from index")
+
+        /* Obtain requested info if the chunk is found */
+        if(udata.found) {
+            if(filter_mask)
+                *filter_mask = udata.filter_mask;
+            if(addr)
+                *addr = udata.chunk_addr;
+            if(size)
+                *size = udata.nbytes;
+            if(offset)
+                for(ii = 0; ii < udata.ndims; ii++)
+                    offset[ii] = udata.scaled[ii] * dset->shared->layout.u.chunk.dim[ii];
+        }
+    } /* end if H5F_addr_defined */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D__get_chunk_info() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__get_chunk_info_by_coord_cb
+ *
+ * Purpose:     Get the chunk info of the desired chunk, given its offset
+ *              coordinates.
+ *
+ * Return:      Success:    H5_ITER_CONT or H5_ITER_STOP
+ *              Failure:    Negative (H5_ITER_ERROR)
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              June 2019 (HDFFV-10677)
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+H5D__get_chunk_info_by_coord_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
+{
+    hsize_t ii;
+    H5D_chunk_info_iter_ud_t *chunk_info = (H5D_chunk_info_iter_ud_t *)_udata;
+    hbool_t different = FALSE;      /* TRUE when a scaled value pair mismatch */
+    int ret_value = H5_ITER_CONT;   /* Callback return value */
+
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Check args */
+    HDassert(chunk_rec);
+    HDassert(chunk_info);
+
+    /* Going through the scaled, stop when a mismatch is found */
+    for (ii = 0; ii < chunk_info->ndims && !different; ii++)
+        if (chunk_info->scaled[ii] != chunk_rec->scaled[ii])
+            different = TRUE;
+
+    /* Same scaled coords means the chunk is found, copy the chunk info */
+    if (!different) {
+        chunk_info->nbytes = chunk_rec->nbytes;
+        chunk_info->filter_mask = chunk_rec->filter_mask;
+        chunk_info->chunk_addr = chunk_rec->chunk_addr;
+        chunk_info->found = TRUE;
+
+        /* Stop iterating */
+        ret_value = H5_ITER_STOP;
+    }
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D__get_chunk_info_by_coord_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D__get_chunk_info_by_coord
+ *
+ * Purpose:     Iterate over the chunks in the dataset to get the info
+ *              of the desired chunk, given by its offset coordinates.
+ *
+ * Return:      Success:        Non-negative
+ *              Failure:        Negative
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              June 2019 (HDFFV-10677)
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5D__get_chunk_info_by_coord(const H5D_t *dset, const hsize_t *offset, unsigned* filter_mask, haddr_t *addr, hsize_t *size)
+{
+    const H5O_layout_t *layout = NULL;  /* Dataset layout */
+    const H5D_rdcc_t   *rdcc = NULL;    /* Raw data chunk cache */
+    H5D_rdcc_ent_t     *ent;            /* Cache entry index */
+    H5D_chk_idx_info_t  idx_info;       /* Chunked index info */
+    H5D_chunk_info_iter_ud_t udata;     /* User data for callback */
+    H5D_chunk_ud_t udata2;
+    hsize_t scaled[H5S_MAX_RANK];
+    herr_t              ret_value = SUCCEED;     /* Return value */
+
+    FUNC_ENTER_PACKAGE_TAG(dset->oloc.addr)
+
+    /* Check args */
+    HDassert(dset);
+    HDassert(dset->shared);
+    HDassert(offset);
+
+    /* Get dataset layout and raw data chunk cache */
+    layout = &(dset->shared->layout);
+    rdcc = &(dset->shared->cache.chunk);
+    HDassert(layout);
+    HDassert(rdcc);
+    HDassert(H5D_CHUNKED == layout->type);
+
+/* Is this expensive? */
+    /* Search for cached chunks that haven't been written out */
+    for(ent = rdcc->head; ent; ent = ent->next)
+        /* Flush the chunk out to disk, to make certain the size is correct later */
+        if(H5D__chunk_flush_entry(dset, ent, FALSE) < 0)
+            HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "cannot flush indexed storage buffer")
+
+    /* Set addr & size for when dset is not written or queried chunk is not found */
+    if (addr)
+        *addr = HADDR_UNDEF;
+    if (size)
+        *size = 0;
+
+    /* Compose chunked index info struct */
+    idx_info.f = dset->oloc.file;
+    idx_info.pline = &dset->shared->dcpl_cache.pline;
+    idx_info.layout = &dset->shared->layout.u.chunk;
+    idx_info.storage = &dset->shared->layout.storage.u.chunk;
+
+    /* If the dataset is not written, return without errors */
+    if(H5F_addr_defined(idx_info.storage->idx_addr)) {
+        /* Calculate the scaled of this chunk */
+        H5VM_chunk_scaled(dset->shared->ndims, offset, layout->u.chunk.dim, udata.scaled);
+        udata.scaled[dset->shared->ndims] = 0;
+
+        /* Initialize before iteration */
+        udata.ndims = dset->shared->ndims;
+        udata.nbytes = 0;
+        udata.filter_mask = 0;
+        udata.chunk_addr = HADDR_UNDEF;
+        udata.found = FALSE;
+
+        /* Iterate over the allocated chunks to find the requested chunk */
+        if((dset->shared->layout.storage.u.chunk.ops->iterate)(&idx_info, H5D__get_chunk_info_by_coord_cb, &udata) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve information of the chunk by its scaled coordinates")
+
+        /* Obtain requested info if the chunk is found */
+        if (udata.found) {
+            if(filter_mask)
+                *filter_mask = udata.filter_mask;
+            if(addr)
+                *addr = udata.chunk_addr;
+            if(size)
+                *size = udata.nbytes;
+        }
+    } /* end if H5F_addr_defined */
+
+done:
+    FUNC_LEAVE_NOAPI_TAG(ret_value)
+} /* end H5D__get_chunk_info_by_coord() */
+
diff --git a/src/H5Dnone.c b/src/H5Dnone.c
index be421b6..9346220 100644
--- a/src/H5Dnone.c
+++ b/src/H5Dnone.c
@@ -242,9 +242,9 @@ H5D__none_idx_iterate(const H5D_chk_idx_info_t *idx_info,
     unsigned u;		/* Local index variable */
     int curr_dim;       /* Current rank */
     hsize_t idx;    	/* Array index of chunk */
-    int ret_value = -1; /* Return value */
+    int ret_value = H5_ITER_CONT; /* Return value */
 
-    FUNC_ENTER_STATIC_NOERR
+    FUNC_ENTER_STATIC
 
     /* Sanity checks */
     HDassert(idx_info);
@@ -266,34 +266,35 @@ H5D__none_idx_iterate(const H5D_chk_idx_info_t *idx_info,
     HDassert(ndims > 0);
 
     /* Iterate over all the chunks in the dataset's dataspace */
-    for(u = 0; u < idx_info->layout->nchunks; u++) {
-	/* Calculate the index of this chunk */
-	idx = H5VM_array_offset_pre(ndims, idx_info->layout->max_down_chunks, chunk_rec.scaled);
-
-	/* Calculate the address of the chunk */
-	chunk_rec.chunk_addr = idx_info->storage->idx_addr + idx * idx_info->layout->size;
-
-	/* Make "generic chunk" callback */
-	if((ret_value = (*chunk_cb)(&chunk_rec, chunk_udata)) < 0)
-	    HERROR(H5E_DATASET, H5E_CALLBACK, "failure in generic chunk iterator callback");
-
-	/* Update coordinates of chunk in dataset */
-	curr_dim = (int)(ndims - 1);
-	while(curr_dim >= 0) {
-	    /* Increment coordinate in current dimension */
-	    chunk_rec.scaled[curr_dim]++;
-
-	    /* Check if we went off the end of the current dimension */
-	    if(chunk_rec.scaled[curr_dim] >= idx_info->layout->chunks[curr_dim]) {
-		/* Reset coordinate & move to next faster dimension */
-		chunk_rec.scaled[curr_dim] = 0;
-		curr_dim--;
-	    } /* end if */
-	    else
-		break;
-	} /* end while */
+    for(u = 0; u < idx_info->layout->nchunks && ret_value == H5_ITER_CONT; u++) {
+	    /* Calculate the index of this chunk */
+	    idx = H5VM_array_offset_pre(ndims, idx_info->layout->max_down_chunks, chunk_rec.scaled);
+
+	    /* Calculate the address of the chunk */
+	    chunk_rec.chunk_addr = idx_info->storage->idx_addr + idx * idx_info->layout->size;
+
+	    /* Make "generic chunk" callback */
+	    if((ret_value = (*chunk_cb)(&chunk_rec, chunk_udata)) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CALLBACK, H5_ITER_ERROR, "failure in generic chunk iterator callback")
+
+	    /* Update coordinates of chunk in dataset */
+	    curr_dim = (int)(ndims - 1);
+	    while(curr_dim >= 0) {
+	        /* Increment coordinate in current dimension */
+	        chunk_rec.scaled[curr_dim]++;
+
+	        /* Check if we went off the end of the current dimension */
+	        if(chunk_rec.scaled[curr_dim] >= idx_info->layout->chunks[curr_dim]) {
+		        /* Reset coordinate & move to next faster dimension */
+		        chunk_rec.scaled[curr_dim] = 0;
+		        curr_dim--;
+	        } /* end if */
+	        else
+		        break;
+	    } /* end while */
     } /* end for */
 
+done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__none_idx_iterate() */
 
diff --git a/src/H5Dpkg.h b/src/H5Dpkg.h
index ed3bc12..723acf9 100644
--- a/src/H5Dpkg.h
+++ b/src/H5Dpkg.h
@@ -569,6 +569,9 @@ H5_DLL herr_t H5D__get_space_status(const H5D_t *dset, H5D_space_status_t *alloc
 H5_DLL herr_t H5D__alloc_storage(const H5D_io_info_t *io_info, H5D_time_alloc_t time_alloc, hbool_t full_overwrite, hsize_t old_dim[]);
 H5_DLL herr_t H5D__get_storage_size(const H5D_t *dset, hsize_t *storage_size);
 H5_DLL herr_t H5D__get_chunk_storage_size(H5D_t *dset, const hsize_t *offset, hsize_t *storage_size);
+H5_DLL herr_t H5D__get_num_chunks(const H5D_t *dset, const H5S_t *space, hsize_t *nchunks);
+H5_DLL herr_t H5D__get_chunk_info(const H5D_t *dset, const H5S_t *space, hsize_t chk_idx, hsize_t *coord, unsigned *filter_mask, haddr_t *offset, hsize_t *size);
+H5_DLL herr_t H5D__get_chunk_info_by_coord(const H5D_t *dset, const hsize_t *coord, unsigned *filter_mask, haddr_t *addr, hsize_t *size);
 H5_DLL haddr_t H5D__get_offset(const H5D_t *dset);
 H5_DLL void *H5D__vlen_get_buf_size_alloc(size_t size, void *info);
 H5_DLL herr_t H5D__vlen_get_buf_size(void *elem, hid_t type_id, unsigned ndim, const hsize_t *point, void *op_data);
diff --git a/src/H5Dpublic.h b/src/H5Dpublic.h
index 63f1a24..7234d16 100644
--- a/src/H5Dpublic.h
+++ b/src/H5Dpublic.h
@@ -142,6 +142,9 @@ H5_DLL hid_t H5Dget_create_plist(hid_t dset_id);
 H5_DLL hid_t H5Dget_access_plist(hid_t dset_id);
 H5_DLL hsize_t H5Dget_storage_size(hid_t dset_id);
 H5_DLL herr_t H5Dget_chunk_storage_size(hid_t dset_id, const hsize_t *offset, hsize_t *chunk_bytes);
+H5_DLL herr_t H5Dget_num_chunks(hid_t dset_id, hid_t fspace_id, hsize_t *nchunks);
+H5_DLL herr_t H5Dget_chunk_info_by_coord(hid_t dset_id, const hsize_t *coord, unsigned *filter_mask, haddr_t *addr, hsize_t *size);
+H5_DLL herr_t H5Dget_chunk_info(hid_t dset_id, hid_t fspace_id, hsize_t chk_idx, hsize_t *coord, unsigned *filter_mask, haddr_t *addr, hsize_t *size);
 H5_DLL haddr_t H5Dget_offset(hid_t dset_id);
 H5_DLL herr_t H5Dread(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id,
 			hid_t file_space_id, hid_t plist_id, void *buf/*out*/);
diff --git a/src/H5EA.c b/src/H5EA.c
index d0bf474..96eee12 100644
--- a/src/H5EA.c
+++ b/src/H5EA.c
@@ -987,19 +987,25 @@ END_FUNC(PRIV)  /* end H5EA_delete() */
  * Purpose:	Iterate over the elements of an extensible array
  *		(copied and modified from FA_iterate() in H5FA.c)
  *
- * Return:      SUCCEED/FAIL
+ * Return:      H5_ITER_CONT/H5_ITER_ERROR
  *
  * Programmer:  Vailin Choi; Feb 2015
  *
+ * Modification:
+ *              Prototype changed (HDFFV-10661)
+ *              - herr_t to int
+ *              - SUCCEED/FAIL to H5_ITER_CONT/H5_ITER_ERROR
+ *              June 6, 2019 -BMR
  *-------------------------------------------------------------------------
  */
 BEGIN_FUNC(PRIV, ERR,
-herr_t, SUCCEED, FAIL,
+int, H5_ITER_CONT, H5_ITER_ERROR,
 H5EA_iterate(H5EA_t *ea, H5EA_operator_t op, void *udata))
 
     /* Local variables */
     uint8_t     *elmt = NULL;
     hsize_t     u;
+    int         cb_ret = H5_ITER_CONT;     /* Return value from callback */
 
     /*
      * Check arguments.
@@ -1013,9 +1019,7 @@ H5EA_iterate(H5EA_t *ea, H5EA_operator_t op, void *udata))
         H5E_THROW(H5E_CANTALLOC, "memory allocation failed for extensible array element")
 
     /* Iterate over all elements in array */
-    for(u = 0; u < ea->hdr->stats.stored.max_idx_set; u++) {
-        int cb_ret;     /* Return value from callback */
-
+    for(u = 0; u < ea->hdr->stats.stored.max_idx_set && cb_ret == H5_ITER_CONT; u++) {
         /* Get array element */
         if(H5EA_get(ea, u, elmt) < 0)
             H5E_THROW(H5E_CANTGET, "unable to delete fixed array")
diff --git a/src/H5FA.c b/src/H5FA.c
index 8c86193..df53f27 100644
--- a/src/H5FA.c
+++ b/src/H5FA.c
@@ -686,20 +686,26 @@ END_FUNC(PRIV)  /* end H5FA_delete() */
  * Note:        This is not very efficient, we should be iterating directly
  *              over the fixed array's direct block [pages].
  *
- * Return:      SUCCEED/FAIL
+ * Return:      H5_ITER_CONT/H5_ITER_ERROR
  *
  * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
+ * Modification:
+ *              Prototype changed (HDFFV-10661)
+ *              - herr_t to int
+ *              - SUCCEED/FAIL to H5_ITER_CONT/H5_ITER_ERROR
+ *              June 6, 2019 -BMR
  *-------------------------------------------------------------------------
  */
 BEGIN_FUNC(PRIV, ERR,
-herr_t, SUCCEED, FAIL,
+int, H5_ITER_CONT, H5_ITER_ERROR,
 H5FA_iterate(H5FA_t *fa, H5FA_operator_t op, void *udata))
 
     /* Local variables */
     uint8_t     *elmt = NULL;
     hsize_t     u;
+    int         cb_ret = H5_ITER_CONT;     /* Return value from callback */
 
     /*
      * Check arguments.
@@ -713,9 +719,7 @@ H5FA_iterate(H5FA_t *fa, H5FA_operator_t op, void *udata))
         H5E_THROW(H5E_CANTALLOC, "memory allocation failed for fixed array element")
 
     /* Iterate over all elements in array */
-    for(u = 0; u < fa->hdr->stats.nelmts; u++) {
-        int cb_ret;     /* Return value from callback */
-
+    for(u = 0; u < fa->hdr->stats.nelmts && cb_ret == H5_ITER_CONT; u++) {
         /* Get array element */
         if(H5FA_get(fa, u, elmt) < 0)
             H5E_THROW(H5E_CANTGET, "unable to delete fixed array")
diff --git a/src/H5VLnative.h b/src/H5VLnative.h
index 1a3007a..73c6189 100644
--- a/src/H5VLnative.h
+++ b/src/H5VLnative.h
@@ -36,8 +36,11 @@ typedef int H5VL_native_dataset_optional_t;
 #define H5VL_NATIVE_DATASET_FORMAT_CONVERT          0   /* H5Dformat_convert (internal) */
 #define H5VL_NATIVE_DATASET_GET_CHUNK_INDEX_TYPE    1   /* H5Dget_chunk_index_type      */
 #define H5VL_NATIVE_DATASET_GET_CHUNK_STORAGE_SIZE  2   /* H5Dget_chunk_storage_size    */
-#define H5VL_NATIVE_DATASET_CHUNK_READ              3   /* H5Dchunk_read                */
-#define H5VL_NATIVE_DATASET_CHUNK_WRITE             4   /* H5Dchunk_write               */
+#define H5VL_NATIVE_DATASET_GET_NUM_CHUNKS          3   /* H5Dget_num_chunks            */
+#define H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_IDX   4   /* H5Dget_chunk_info            */
+#define H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_COOR  5   /* H5Dget_chunk_info_by_coord   */
+#define H5VL_NATIVE_DATASET_CHUNK_READ              6   /* H5Dchunk_read                */
+#define H5VL_NATIVE_DATASET_CHUNK_WRITE             7   /* H5Dchunk_write               */
 
 /* Typedef and values for native VOL connector file optional VOL operations */
 typedef int H5VL_native_file_optional_t;
diff --git a/src/H5VLnative_dataset.c b/src/H5VLnative_dataset.c
index 1e3d263..631eb19 100644
--- a/src/H5VLnative_dataset.c
+++ b/src/H5VLnative_dataset.c
@@ -339,7 +339,7 @@ H5VL__native_dataset_specific(void *obj, H5VL_dataset_specific_t specific_type,
     switch(specific_type) {
         /* H5Dspecific_space */
         case H5VL_DATASET_SET_EXTENT:
-            {
+            { /* H5Dset_extent (H5Dextend - deprecated) */
                 const hsize_t *size = HDva_arg(arguments, const hsize_t *); 
 
                 if(H5D__set_extent(dset, size) < 0)
@@ -348,7 +348,7 @@ H5VL__native_dataset_specific(void *obj, H5VL_dataset_specific_t specific_type,
             }
 
         case H5VL_DATASET_FLUSH:
-            {
+            { /* H5Dflush */
                 hid_t dset_id = HDva_arg(arguments, hid_t);
 
                 /* Flush the dataset */
@@ -359,7 +359,7 @@ H5VL__native_dataset_specific(void *obj, H5VL_dataset_specific_t specific_type,
             }
 
         case H5VL_DATASET_REFRESH:
-            {
+            { /* H5Drefresh */
                 hid_t dset_id = HDva_arg(arguments, hid_t);
 
                 /* Refresh the dataset */
@@ -399,7 +399,7 @@ H5VL__native_dataset_optional(void *obj, hid_t H5_ATTR_UNUSED dxpl_id,
 
     switch(optional_type) {
         case H5VL_NATIVE_DATASET_FORMAT_CONVERT:
-            {
+            {   /* H5Dformat_convert */
                 dset = (H5D_t *)obj;
 
                 switch(dset->shared->layout.type) {
@@ -434,7 +434,7 @@ H5VL__native_dataset_optional(void *obj, hid_t H5_ATTR_UNUSED dxpl_id,
             }
 
         case H5VL_NATIVE_DATASET_GET_CHUNK_INDEX_TYPE:
-            {
+            {   /* H5Dget_chunk_index_type */
                 H5D_chunk_index_t *idx_type = HDva_arg(arguments, H5D_chunk_index_t *);
 
                 dset = (H5D_t *)obj;
@@ -450,7 +450,7 @@ H5VL__native_dataset_optional(void *obj, hid_t H5_ATTR_UNUSED dxpl_id,
             }
 
         case H5VL_NATIVE_DATASET_GET_CHUNK_STORAGE_SIZE:
-            {
+            {   /* H5Dget_chunk_storage_size */
                 hsize_t *offset = HDva_arg(arguments, hsize_t *);
                 hsize_t *chunk_nbytes = HDva_arg(arguments, hsize_t *);
 
@@ -467,8 +467,94 @@ H5VL__native_dataset_optional(void *obj, hid_t H5_ATTR_UNUSED dxpl_id,
                 break;
             }
 
+        case H5VL_NATIVE_DATASET_GET_NUM_CHUNKS:
+            {   /* H5Dget_num_chunks */
+                const H5S_t *space    = NULL;
+                hid_t        space_id = HDva_arg(arguments, hid_t);
+                hsize_t     *nchunks  = HDva_arg(arguments, hsize_t *);
+
+                dset = (H5D_t *)obj;
+                HDassert(dset);
+                HDassert(dset->shared);
+                HDassert(dset->shared->space);
+
+                /* When default dataspace is given, use the dataset's dataspace */
+                if(space_id == H5S_ALL)
+                    space = dset->shared->space;
+                else /*  otherwise, use the given space ID */
+                    if(NULL == (space = (const H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a valid dataspace ID")
+
+                /* Make sure the dataset is chunked */
+                if(H5D_CHUNKED != dset->shared->layout.type)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a chunked dataset")
+
+                /* Call private function */
+                if(H5D__get_num_chunks(dset, space, nchunks) < 0)
+                    HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get number of chunks")
+
+                break;
+            }
+
+        case H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_IDX:
+            {   /* H5Dget_chunk_info */
+                const H5S_t *space = NULL;
+                hid_t        space_id    = HDva_arg(arguments, hid_t);
+                hsize_t      chk_index   = HDva_arg(arguments, hsize_t);
+                hsize_t     *offset = HDva_arg(arguments, hsize_t *);
+                unsigned    *filter_mask = HDva_arg(arguments, unsigned *);
+                haddr_t     *addr        = HDva_arg(arguments, haddr_t *);
+                hsize_t     *size        = HDva_arg(arguments, hsize_t *);
+
+                dset = (H5D_t *)obj;
+                HDassert(dset);
+                HDassert(dset->shared);
+
+                /* When default dataspace is given, use the dataset's dataspace */
+                if(space_id == H5S_ALL)
+                {
+                    space = dset->shared->space;
+                    if(NULL == space)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "unable to obtain a dataspace")
+                }  /*  otherwise, use the given space ID */
+                else
+                    if(NULL == (space = (const H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a valid dataspace ID")
+
+                /* Make sure the dataset is chunked */
+                if(H5D_CHUNKED != dset->shared->layout.type)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a chunked dataset")
+
+                /* Call private function */
+                if(H5D__get_chunk_info(dset, space, chk_index, offset, filter_mask, addr, size) < 0)
+                    HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk info by index")
+                break;
+            }
+
+        case H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_COOR:
+            {   /* H5Dget_chunk_info_by_coord */
+                hsize_t  *offset      = HDva_arg(arguments, hsize_t *);
+                unsigned *filter_mask = HDva_arg(arguments, unsigned *);
+                haddr_t  *addr        = HDva_arg(arguments, haddr_t *);
+                hsize_t  *size        = HDva_arg(arguments, hsize_t *);
+
+                dset = (H5D_t *)obj;
+                HDassert(dset);
+                HDassert(dset->shared);
+
+                /* Make sure the dataset is chunked */
+                if(H5D_CHUNKED != dset->shared->layout.type)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a chunked dataset")
+
+                /* Call private function */
+                if(H5D__get_chunk_info_by_coord(dset, offset, filter_mask, addr, size) < 0)
+                    HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk info by its logical coordinates")
+
+                break;
+            }
+
         case H5VL_NATIVE_DATASET_CHUNK_READ:
-            {
+            {   /* H5Dread_chunk */
                 const       hsize_t *offset     = HDva_arg(arguments, hsize_t *);
                 uint32_t   *filters             = HDva_arg(arguments, uint32_t *);
                 void       *buf                 = HDva_arg(arguments, void *);
@@ -496,7 +582,7 @@ H5VL__native_dataset_optional(void *obj, hid_t H5_ATTR_UNUSED dxpl_id,
             }
 
         case H5VL_NATIVE_DATASET_CHUNK_WRITE:
-            {
+            {   /* H5Dwrite_chunk */
                 uint32_t        filters             = HDva_arg(arguments, uint32_t);
                 const  hsize_t *offset              = HDva_arg(arguments, const hsize_t *);
                 uint32_t        data_size_32        = HDva_arg(arguments, uint32_t);