Trim trailing whitespace

1 files changed, 308 insertions, 308 deletions

diff --git a/src/H5HFcache.c b/src/H5HFcache.c
index 4a2ff91..8dbdf25 100644
--- a/src/H5HFcache.c
+++ b/src/H5HFcache.c
@@ -77,35 +77,35 @@ static herr_t H5HF__cache_hdr_get_final_load_size(const void *image_ptr,
     size_t image_len, void *udata, size_t *actual_len);
 static htri_t H5HF__cache_hdr_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);
 static void *H5HF__cache_hdr_deserialize(const void *image, size_t len,
-    void *udata, hbool_t *dirty); 
+    void *udata, hbool_t *dirty);
 static herr_t H5HF__cache_hdr_image_len(const void *thing, size_t *image_len);
 static herr_t H5HF__cache_hdr_pre_serialize(H5F_t *f, void *thing, haddr_t addr,
-    size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags); 
+    size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags);
 static herr_t H5HF__cache_hdr_serialize(const H5F_t *f, void *image,
-    size_t len, void *thing); 
+    size_t len, void *thing);
 static herr_t H5HF__cache_hdr_free_icr(void *thing);
 
 static herr_t H5HF__cache_iblock_get_initial_load_size(void *udata, size_t *image_len);
 static htri_t H5HF__cache_iblock_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);
 static void *H5HF__cache_iblock_deserialize(const void *image, size_t len,
-    void *udata, hbool_t *dirty); 
+    void *udata, hbool_t *dirty);
 static herr_t H5HF__cache_iblock_image_len(const void *thing, size_t *image_len);
 static herr_t H5HF__cache_iblock_pre_serialize(H5F_t *f, void *thing,
-    haddr_t addr, size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags); 
+    haddr_t addr, size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags);
 static herr_t H5HF__cache_iblock_serialize(const H5F_t *f, void *image,
-    size_t len, void *thing); 
-static herr_t H5HF__cache_iblock_notify(H5AC_notify_action_t action, void *thing); 
+    size_t len, void *thing);
+static herr_t H5HF__cache_iblock_notify(H5AC_notify_action_t action, void *thing);
 static herr_t H5HF__cache_iblock_free_icr(void *thing);
 
 static herr_t H5HF__cache_dblock_get_initial_load_size(void *udata, size_t *image_len);
 static htri_t H5HF__cache_dblock_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);
 static void *H5HF__cache_dblock_deserialize(const void *image, size_t len,
-    void *udata, hbool_t *dirty); 
+    void *udata, hbool_t *dirty);
 static herr_t H5HF__cache_dblock_image_len(const void *thing, size_t *image_len);
 static herr_t H5HF__cache_dblock_pre_serialize(H5F_t *f, void *thing, haddr_t addr,
-    size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags); 
+    size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags);
 static herr_t H5HF__cache_dblock_serialize(const H5F_t *f, void *image,
-    size_t len, void *thing); 
+    size_t len, void *thing);
 static herr_t H5HF__cache_dblock_notify(H5AC_notify_action_t action, void *thing);
 static herr_t H5HF__cache_dblock_free_icr(void *thing);
 static herr_t H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size);
@@ -114,14 +114,14 @@ static herr_t H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
 #ifndef NDEBUG
 static herr_t H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
     hbool_t *fd_clean, hbool_t *clean);
-static herr_t H5HF__cache_verify_iblock_descendants_clean(H5F_t *f, 
+static herr_t H5HF__cache_verify_iblock_descendants_clean(H5F_t *f,
     haddr_t fd_parent_addr, H5HF_indirect_t *iblock, unsigned *iblock_status,
     hbool_t *fd_clean, hbool_t *clean);
-static herr_t H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, 
-    haddr_t fd_parent_addr, H5HF_indirect_t *iblock, hbool_t *fd_clean, 
+static herr_t H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f,
+    haddr_t fd_parent_addr, H5HF_indirect_t *iblock, hbool_t *fd_clean,
     hbool_t *clean, hbool_t *has_dblocks);
-static herr_t H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, 
-    haddr_t fd_parent_addr, H5HF_indirect_t *iblock, 
+static herr_t H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f,
+    haddr_t fd_parent_addr, H5HF_indirect_t *iblock,
     hbool_t *fd_clean, hbool_t *clean, hbool_t *has_iblocks);
 #endif /* NDEBUG */
 
@@ -212,7 +212,7 @@ H5FL_BLK_DEFINE(direct_block);
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__hdr_prefix_decode(H5HF_hdr_t *hdr, const uint8_t **image_ref)
 {
     const uint8_t *image = *image_ref;  /* Pointer into into supplied image */
@@ -351,8 +351,8 @@ H5HF__dtable_encode(H5F_t *f, uint8_t **pp, const H5HF_dtable_t *dtable)
  * Purpose:	Determine the size of the fractal heap header on disk,
  *		and set *image_len to this value.
  *
- *		Note also that the value returned by this function presumes that 
- *		there is no I/O filtering data in the header.  If there is, the 
+ *		Note also that the value returned by this function presumes that
+ *		there is no I/O filtering data in the header.  If there is, the
  *		size reported will be too small, and H5C_load_entry()
  *		will have to make two tries to load the fractal heap header.
  *
@@ -364,7 +364,7 @@ H5HF__dtable_encode(H5F_t *f, uint8_t **pp, const H5HF_dtable_t *dtable)
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_hdr_get_initial_load_size(void *_udata, size_t *image_len)
 {
     H5HF_hdr_cache_ud_t *udata = (H5HF_hdr_cache_ud_t *)_udata; /* Pointer to user data */
@@ -402,7 +402,7 @@ H5HF__cache_hdr_get_initial_load_size(void *_udata, size_t *image_len)
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_hdr_get_final_load_size(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED image_len,
     void *_udata, size_t *actual_len)
 {
@@ -609,11 +609,11 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_hdr_image_len
  *
- * Purpose:	Return the actual size of the fractal heap header on 
- *		disk image.  
+ * Purpose:	Return the actual size of the fractal heap header on
+ *		disk image.
  *
- *		If the header contains filter information, this size will be 
- *		larger than the value returned by H5HF__cache_hdr_get_initial_load_size().  
+ *		If the header contains filter information, this size will be
+ *		larger than the value returned by H5HF__cache_hdr_get_initial_load_size().
  *
  * Return:	Success:	SUCCEED
  *		Failure:	FAIL
@@ -623,7 +623,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_hdr_image_len(const void *_thing, size_t *image_len)
 {
     const H5HF_hdr_t  *hdr = (const H5HF_hdr_t *)_thing;    /* Fractal heap info */
@@ -645,13 +645,13 @@ H5HF__cache_hdr_image_len(const void *_thing, size_t *image_len)
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_hdr_pre_serialize
  *
- * Purpose:	As best I can tell, fractal heap header blocks are always 
+ * Purpose:	As best I can tell, fractal heap header blocks are always
  *		allocated in real file space.  Thus this routine simply verifies
  *		this, verifies that the len parameter contains the expected
  *		value, and returns an error if either of these checks fail.
  *
  *		When compiled in debug mode, the function also verifies that all
- *		indirect and direct blocks that are children of the header are 
+ *		indirect and direct blocks that are children of the header are
  *		either clean, or not in the metadata cache.
  *
  * Return:	Success:	SUCCEED
@@ -662,7 +662,7 @@ H5HF__cache_hdr_image_len(const void *_thing, size_t *image_len)
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t len,
     haddr_t H5_ATTR_UNUSED *new_addr, size_t H5_ATTR_UNUSED *new_len,
     unsigned *flags)
@@ -706,8 +706,8 @@ H5HF__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t len,
      * is made during a cache serialization instead of an entry or cache
      * flush.
      *
-     * Note also that with the recent change in the definition of flush 
-     * dependency, not all descendants need be clean -- only direct flush 
+     * Note also that with the recent change in the definition of flush
+     * dependency, not all descendants need be clean -- only direct flush
      * dependency children.
      *
      * Finally, observe that the H5HF__cache_verify_hdr_descendants_clean()
@@ -736,7 +736,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_hdr_serialize
  *
- * Purpose:	Construct the on disk image of the header, and place it in 
+ * Purpose:	Construct the on disk image of the header, and place it in
  *		the buffer pointed to by image.  Return SUCCEED on success,
  *		and FAIL on failure.
  *
@@ -748,7 +748,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UNUSED len,
     void *_thing)
 {
@@ -846,7 +846,7 @@ done:
  *
  * Purpose:	Free the in core representation of the fractal heap header.
  *
- *		This routine frees just the header itself, not the 
+ *		This routine frees just the header itself, not the
  *		associated version 2 B-Tree, the associated Free Space Manager,
  *		nor the indirect/direct block tree that is rooted in the header.
  *
@@ -865,7 +865,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_hdr_free_icr(void *_thing)
 {
     H5HF_hdr_t *hdr = (H5HF_hdr_t *)_thing;     /* Fractal heap info */
@@ -890,7 +890,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_iblock_get_initial_load_size()
  *
- * Purpose:	Compute the size of the on disk image of the indirect 
+ * Purpose:	Compute the size of the on disk image of the indirect
  *		block, and place this value in *image_len.
  *
  * Return:	Success:	SUCCEED
@@ -901,7 +901,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_iblock_get_initial_load_size(void *_udata, size_t *image_len)
 {
     H5HF_iblock_cache_ud_t *udata = (H5HF_iblock_cache_ud_t *)_udata;   /* User data for callback */
@@ -913,7 +913,7 @@ H5HF__cache_iblock_get_initial_load_size(void *_udata, size_t *image_len)
     HDassert(udata->par_info);
     HDassert(udata->par_info->hdr);
     HDassert(image_len);
-   
+
     /* Set the image length size */
     *image_len = (size_t)H5HF_MAN_INDIRECT_SIZE(udata->par_info->hdr, *udata->nrows);
 
@@ -961,9 +961,9 @@ H5HF__cache_iblock_verify_chksum(const void *_image, size_t len, void H5_ATTR_UN
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_iblock_deserialize
  *
- * Purpose:	Given a buffer containing the on disk image of the indirect 
- *		block, allocate an instance of H5HF_indirect_t, load the data 
- *		in the buffer into this new instance, and return a pointer to 
+ * Purpose:	Given a buffer containing the on disk image of the indirect
+ *		block, allocate an instance of H5HF_indirect_t, load the data
+ *		in the buffer into this new instance, and return a pointer to
  *		it.
  *
  *		As best I can tell, the size of the indirect block image is fully
@@ -979,7 +979,7 @@ H5HF__cache_iblock_verify_chksum(const void *_image, size_t len, void H5_ATTR_UN
  *-------------------------------------------------------------------------
  */
 static void *
-H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len, 
+H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len,
     void *_udata, hbool_t H5_ATTR_UNUSED *dirty)
 {
     H5HF_hdr_t          *hdr;           /* Shared fractal heap information */
@@ -1164,7 +1164,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_iblock_image_len(const void *_thing, size_t *image_len)
 {
     const H5HF_indirect_t *iblock = (const H5HF_indirect_t *)_thing;    /* Indirect block info */
@@ -1188,11 +1188,11 @@ H5HF__cache_iblock_image_len(const void *_thing, size_t *image_len)
  *
  * Purpose:	The primary objective of this function is to determine if the
  *		indirect block is currently allocated in temporary file space,
- *		and if so, to move it to real file space before the entry is 
+ *		and if so, to move it to real file space before the entry is
  *		serialized.
  *
- *		In debug compiles, this function also verifies that all 
- *		immediate flush dependency children of this indirect block 
+ *		In debug compiles, this function also verifies that all
+ *		immediate flush dependency children of this indirect block
  *		are either clean or are not in cache.
  *
  * Return:	Success:	SUCCEED
@@ -1203,7 +1203,7 @@ H5HF__cache_iblock_image_len(const void *_thing, size_t *image_len)
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr,
     size_t H5_ATTR_UNUSED len, haddr_t *new_addr, size_t H5_ATTR_UNUSED *new_len,
     unsigned *flags)
@@ -1237,7 +1237,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr,
     unsigned 		 iblock_status = 0;
 
     /* verify that flush dependencies are working correctly.  Do this
-     * by verifying that all immediate flush dependency children of this 
+     * by verifying that all immediate flush dependency children of this
      * iblock are clean.
      */
     if(H5AC_get_entry_status(f, iblock->addr, &iblock_status) < 0)
@@ -1254,7 +1254,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr,
 }
 #endif /* NDEBUG */
 
-    /* Check to see if we must re-allocate the iblock from temporary to 
+    /* Check to see if we must re-allocate the iblock from temporary to
      * normal (AKA real) file space.
      */
     if(H5F_IS_TMP_ADDR(f, addr)) {
@@ -1302,7 +1302,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr,
 	*new_addr = iblock_addr;
         *flags = H5AC__SERIALIZE_MOVED_FLAG;
     } /* end if */
-    else 
+    else
 	*flags = 0;
 
 done:
@@ -1313,8 +1313,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_iblock_serialize
  *
- * Purpose:	Given a pointer to an iblock, and a pointer to a buffer of 
- *		the appropriate size, write the contents of the iblock to the 
+ * Purpose:	Given a pointer to an iblock, and a pointer to a buffer of
+ *		the appropriate size, write the contents of the iblock to the
  *		buffer in format appropriate for writing to disk.
  *
  * Return:	Success:	SUCCEED
@@ -1325,7 +1325,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UNUSED len,
     void *_thing)
 {
@@ -1390,7 +1390,7 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG
                 /* (either both the address & size are defined or both are
                  *  not defined)
                  */
-                HDassert((H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size) 
+                HDassert((H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size)
                         || (!H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size == 0));
 
                 /* Size of filtered direct block */
@@ -1431,11 +1431,11 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_iblock_notify
  *
- * Purpose:	This function is used to create and destroy flush dependency 
+ * Purpose:	This function is used to create and destroy flush dependency
  *		relationships between iblocks and their parents as indirect blocks
  *		are loaded / inserted and evicted from the metadata cache.
  *
- *		In general, the parent will be another iblock, but it may be the 
+ *		In general, the parent will be another iblock, but it may be the
  *		header if the iblock in question is the root iblock.
  *
  * Return:	Success:	SUCCEED
@@ -1446,7 +1446,7 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_iblock_notify(H5AC_notify_action_t action, void *_thing)
 {
     H5HF_indirect_t     *iblock = (H5HF_indirect_t *)_thing;    /* Indirect block info */
@@ -1528,7 +1528,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_iblock_free_icr
  *
- * Purpose:	Unlink the supplied instance of H5HF_indirect_t from the 
+ * Purpose:	Unlink the supplied instance of H5HF_indirect_t from the
  *		fractal heap and free its memory.
  *
  * Note:	The metadata cache sets the object's cache_info.magic to
@@ -1543,7 +1543,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_iblock_free_icr(void *thing)
 {
     H5HF_indirect_t	*iblock = (H5HF_indirect_t *)thing;     /* Fractal heap indirect block to free */
@@ -1570,7 +1570,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_dblock_get_initial_load_size()
  *
- * Purpose:	Determine the size of the direct block on disk image, and 
+ * Purpose:	Determine the size of the direct block on disk image, and
  *		return it in *image_len.
  *
  * Return:	Success:	SUCCEED
@@ -1581,7 +1581,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_dblock_get_initial_load_size(void *_udata, size_t *image_len)
 {
     const H5HF_dblock_cache_ud_t *udata = (const H5HF_dblock_cache_ud_t *)_udata;    /* User data for callback */
@@ -1612,7 +1612,7 @@ H5HF__cache_dblock_get_initial_load_size(void *_udata, size_t *image_len)
     }  /* end if */
     else
         *image_len = udata->dblock_size;
-    
+
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5HF__cache_dblock_get_initial_load_size() */
 
@@ -1668,7 +1668,7 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
         filter_cb.func = NULL;      /* no callback function when failed */
 
         /* Allocate buffer to perform I/O filtering on and copy image into
-         * it.  Must do this as H5Z_pipeline() may re-size the buffer 
+         * it.  Must do this as H5Z_pipeline() may re-size the buffer
          * provided to it.
          */
         if(NULL == (read_buf = H5MM_malloc(len)))
@@ -1801,7 +1801,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata,
     /* Check for I/O filters on this heap */
     if(hdr->filter_len > 0) {
         /* Direct block is already decompressed in verify_chksum callback */
-        if(udata->decompressed) { 
+        if(udata->decompressed) {
             /* Sanity check */
             HDassert(udata->dblk);
 
@@ -1822,7 +1822,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata,
             filter_cb.func = NULL;      /* no callback function when failed */
 
             /* Allocate buffer to perform I/O filtering on and copy image into
-             * it.  Must do this as H5Z_pipeline() may resize the buffer 
+             * it.  Must do this as H5Z_pipeline() may resize the buffer
              * provided to it.
              */
             if (NULL == (read_buf = H5MM_malloc(len)))
@@ -1926,7 +1926,7 @@ done:
  * Function:	H5HF__cache_dblock_image_len
  *
  * Purpose:	Report the actual size of the direct block image on disk.
- *		Note that this value will probably be incorrect if compression 
+ *		Note that this value will probably be incorrect if compression
  *		is enabled and the entry is dirty.
  *
  * Return:	Success:	SUCCEED
@@ -1937,7 +1937,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_dblock_image_len(const void *_thing, size_t *image_len)
 {
     const H5HF_direct_t    *dblock = (const H5HF_direct_t *)_thing;     /* Direct block info */
@@ -1958,32 +1958,32 @@ H5HF__cache_dblock_image_len(const void *_thing, size_t *image_len)
 
     /* Check for I/O filters on this heap */
     if(hdr->filter_len > 0) {
-        /* 
+        /*
          * If the data is available, set to the compressed
-         * size of the direct block -- otherwise set it equal to the 
-         * uncompressed size.  
+         * size of the direct block -- otherwise set it equal to the
+         * uncompressed size.
          *
          * We have three possible scenarios here.
          *
          * First, the block may never have been flushed.  In this
-         * case, both dblock->file_size and the size stored in the 
-         * parent (either the header or the parent iblock) will all 
-         * be zero.  In this case, return the uncompressed size 
+         * case, both dblock->file_size and the size stored in the
+         * parent (either the header or the parent iblock) will all
+         * be zero.  In this case, return the uncompressed size
          * stored in dblock->size as the size.
          *
          * Second, the block may have just been serialized, in which
-         * case, dblock->file_size should be zero, and the correct 
+         * case, dblock->file_size should be zero, and the correct
          * on disk size should be stored in the parent (again, either
          * the header or the parent iblock as case may be).
-         * 
-         * Third, we may be in the process of discarding this 
+         *
+         * Third, we may be in the process of discarding this
          * dblock without writing it.  In this case, dblock->file_size
-         * should be non-zero and have the correct size.  Note that 
+         * should be non-zero and have the correct size.  Note that
          * in this case, the direct block will have been detached,
          * and thus looking up the parent will likely return incorrect
          * data.
          */
-        if(dblock->file_size != 0) 
+        if(dblock->file_size != 0)
             size = dblock->file_size;
         else {
             const H5HF_indirect_t  *par_iblock = dblock->parent; /* Parent iblock */
@@ -2012,54 +2012,54 @@ H5HF__cache_dblock_image_len(const void *_thing, size_t *image_len)
  * Function:	H5HF__cache_dblock_pre_serialize
  *
  * Purpose:	In principle, the purpose of this function is to determine
- *		the size and location of the disk image of the target direct 
+ *		the size and location of the disk image of the target direct
  *		block.  In this case, the uncompressed size of the block is
- *		fixed, but since the direct block could be compressed, 
+ *		fixed, but since the direct block could be compressed,
  *		we may need to compute and report the compressed size.
  *
- *		This is a bit sticky in the case of a direct block when I/O 
+ *		This is a bit sticky in the case of a direct block when I/O
  *		filters are enabled, as the size of the compressed version
- *		of the on disk image is not known until the direct block has 
- *		been run through the filters.  Further, the location of the 
- *		on disk image may change if the compressed size of the image 
+ *		of the on disk image is not known until the direct block has
+ *		been run through the filters.  Further, the location of the
+ *		on disk image may change if the compressed size of the image
  *		changes as well.
  *
- *		To complicate matters further, the direct block may have been 
- *		initially allocated in temporary (AKA imaginary) file space. 
- *		In this case, we must relocate the direct block's on-disk 
- *		image to "real" file space regardless of whether it has changed 
+ *		To complicate matters further, the direct block may have been
+ *		initially allocated in temporary (AKA imaginary) file space.
+ *		In this case, we must relocate the direct block's on-disk
+ *		image to "real" file space regardless of whether it has changed
  *		size.
  *
- *		One simplifying factor is the direct block's "blk" field, 
+ *		One simplifying factor is the direct block's "blk" field,
  *		which contains a pointer to a buffer which (with the exception
- *		of a small header) contains the on disk image in uncompressed 
+ *		of a small header) contains the on disk image in uncompressed
  *		form.
  *
- *		To square this particular circle, this function does 
- *		everything the serialize function usually does, with the 
- *		exception of copying the image into the image buffer provided 
- *		to the serialize function by the metadata cache.  The data to 
+ *		To square this particular circle, this function does
+ *		everything the serialize function usually does, with the
+ *		exception of copying the image into the image buffer provided
+ *		to the serialize function by the metadata cache.  The data to
  *		copy is provided to the serialize function in a buffer pointed
  *		to by the write_buf field.
  *
- *		If I/O filters are enabled, on exit, 
- *		H5HF__cache_dblock_pre_serialize() sets the write_buf field to 
+ *		If I/O filters are enabled, on exit,
+ *		H5HF__cache_dblock_pre_serialize() sets the write_buf field to
  *		point to a buffer containing the filtered image of the direct
  *		block.  The serialize function should free this block, and set
- *		the write_buf field to NULL after copying it into the image 
+ *		the write_buf field to NULL after copying it into the image
  *		buffer provided by the metadata cache.
  *
- *		If I/O filters are not enabled, this function prepares 
- *		the buffer pointed to by the blk field for copying to the 
- *		image buffer provided by the metadata cache, and sets the 
- *		write_buf field equal to the blk field.  In this case, the 
- *		serialize function should simply set the write_buf field to 
- *		NULL after copying the direct block image into the image 
+ *		If I/O filters are not enabled, this function prepares
+ *		the buffer pointed to by the blk field for copying to the
+ *		image buffer provided by the metadata cache, and sets the
+ *		write_buf field equal to the blk field.  In this case, the
+ *		serialize function should simply set the write_buf field to
+ *		NULL after copying the direct block image into the image
  *		buffer.
  *
- *		In both of the above cases, the length of the buffer pointed 
- *		to by write_buf is provided in the write_len field.  This 
- *		field must contain 0 on entry to this function, and should 
+ *		In both of the above cases, the length of the buffer pointed
+ *		to by write_buf is provided in the write_len field.  This
+ *		field must contain 0 on entry to this function, and should
  *		be set back to 0 at the end of the serialize function.
  *
  * Return:	Success:	SUCCEED
@@ -2070,7 +2070,7 @@ H5HF__cache_dblock_image_len(const void *_thing, size_t *image_len)
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
     haddr_t addr, size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags)
 {
@@ -2114,10 +2114,10 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
     HDassert(hdr->cache_info.type == H5AC_FHEAP_HDR);
 
     if(dblock->parent) {
-	/* this is the common case, in which the direct block is the child 
+	/* this is the common case, in which the direct block is the child
          * of an indirect block.  Set up the convenience variables we will
-         * need if the address and/or compressed size of the on disk image 
-         * of the direct block changes, and do some sanity checking in 
+         * need if the address and/or compressed size of the on disk image
+         * of the direct block changes, and do some sanity checking in
          * passing.
          */
         par_iblock = dblock->parent;
@@ -2137,8 +2137,8 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
     at_tmp_addr = H5F_IS_TMP_ADDR(f, addr);
 
     /* Begin by preping the direct block to be written to disk.  Do
-     * this by writing the correct magic number, the dblock version, 
-     * the address of the header, the offset of the block in the heap, 
+     * this by writing the correct magic number, the dblock version,
+     * the address of the header, the offset of the block in the heap,
      * and the checksum at the beginning of the block.
      */
 
@@ -2172,7 +2172,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
         UINT32ENCODE(image, metadata_chksum);
     } /* end if */
 
-    /* at this point, dblock->blk should point to an uncompressed image of 
+    /* at this point, dblock->blk should point to an uncompressed image of
      * the direct block.  If I/O filters are not enabled, this image should
      * be ready to hand off to the metadata cache.
      */
@@ -2211,10 +2211,10 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
         /* Use the compressed number of bytes as the size to write */
         write_size = nbytes;
 
-        /* If the size and/or location of the on disk image of the 
+        /* If the size and/or location of the on disk image of the
          * direct block changes, we must touch up its parent to reflect
          * these changes.  Do this differently depending on whether the
-         * direct block's parent is an indirect block or (rarely) the 
+         * direct block's parent is an indirect block or (rarely) the
          * fractal heap header.  In this case, the direct block is known
          * as a root direct block.
          */
@@ -2233,7 +2233,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
                 hdr_changed = TRUE;
             } /* end if */
 
-            /* verify that the cache's last record of the compressed 
+            /* verify that the cache's last record of the compressed
              * size matches the heap's last record.  This value will
              * likely change shortly.
              */
@@ -2241,10 +2241,10 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
 
             /* Check if we need to re-size the block on disk */
             if(hdr->pline_root_direct_size != write_size || at_tmp_addr) {
-                /* Check if the direct block is NOT currently allocated 
-                 * in temp. file space 
+                /* Check if the direct block is NOT currently allocated
+                 * in temp. file space
                  *
-                 * (temp. file space does not need to be freed) 
+                 * (temp. file space does not need to be freed)
                  */
                 if(!at_tmp_addr)
                     /* Release direct block's current disk space */
@@ -2255,8 +2255,8 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
                 if(HADDR_UNDEF == (dblock_addr = H5MF_alloc((H5F_t *)f, H5FD_MEM_FHEAP_DBLOCK, (hsize_t)write_size)))
                     HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap direct block")
 
-                /* Update information about compressed direct block's 
-                 * location & size 
+                /* Update information about compressed direct block's
+                 * location & size
                  */
                 HDassert(hdr->man_dtable.table_addr == addr);
                 HDassert(hdr->pline_root_direct_size == len);
@@ -2285,7 +2285,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
                 par_changed = TRUE;
             } /* end if */
 
-            /* verify that the cache's last record of the compressed 
+            /* verify that the cache's last record of the compressed
              * size matches the heap's last record.  This value will
              * likely change shortly.
              */
@@ -2293,10 +2293,10 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
 
             /* Check if we need to re-size the block on disk */
             if(par_iblock->filt_ents[par_entry].size != write_size || at_tmp_addr) {
-                /* Check if the direct block is NOT currently allocated 
-                 * in temp. file space 
+                /* Check if the direct block is NOT currently allocated
+                 * in temp. file space
                  *
-                 * (temp. file space does not need to be freed) 
+                 * (temp. file space does not need to be freed)
                  */
                 if(!at_tmp_addr)
                     /* Release direct block's current disk space */
@@ -2307,8 +2307,8 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
                 if(HADDR_UNDEF == (dblock_addr = H5MF_alloc((H5F_t *)f, H5FD_MEM_FHEAP_DBLOCK, (hsize_t)write_size)))
                     HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap direct block")
 
-                /* Update information about compressed direct block's 
-                 * location & size 
+                /* Update information about compressed direct block's
+                 * location & size
                  */
                 HDassert(par_iblock->ents[par_entry].addr == addr);
                 HDassert(par_iblock->filt_ents[par_entry].size == len);
@@ -2326,21 +2326,21 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
         } /* end else */
     } /* end if */
     else {
-        /* I/O filters are not enabled -- thus all we need to do is check to 
-         * see if the direct block is in temporary (AKA imaginary) file 
+        /* I/O filters are not enabled -- thus all we need to do is check to
+         * see if the direct block is in temporary (AKA imaginary) file
          * space, and move it to real file space if it is.
          *
-         * As in the I/O filters case above, we will have to touch up the 
+         * As in the I/O filters case above, we will have to touch up the
          * direct blocks parent if the direct block is relocated.
          *
-         * Recall that temporary file space need not be freed, which 
+         * Recall that temporary file space need not be freed, which
          * simplifies matters slightly.
          */
         write_buf = dblock->blk;
         write_size = dblock->size;
 
-        /* Check to see if we must re-allocate direct block from 'temp.' 
-         * to 'normal' file space 
+        /* Check to see if we must re-allocate direct block from 'temp.'
+         * to 'normal' file space
          */
         if(at_tmp_addr) {
             /* Allocate 'normal' space for the direct block */
@@ -2377,9 +2377,9 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
         } /* end if */
     } /* end else */
 
-    /* At this point, write_buf points to a buffer containing the image 
+    /* At this point, write_buf points to a buffer containing the image
      * of the direct block that is ready to copy into the image buffer,
-     * and write_size contains the length of this buffer. 
+     * and write_size contains the length of this buffer.
      *
      * Also, if image size or address has changed, the direct block's
      * parent has been modified to reflect the change.
@@ -2419,14 +2419,14 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5HF__cache_dblock_serialize
  *
- * Purpose:	In principle, this function is supposed to construct the on 
- *		disk image of the direct block, and place that image in the 
+ * Purpose:	In principle, this function is supposed to construct the on
+ *		disk image of the direct block, and place that image in the
  *		image buffer provided by the metadata cache.
  *
- *		However, since there are cases in which the pre_serialize 
- *		function has to construct the on disk image to determine its size 
+ *		However, since there are cases in which the pre_serialize
+ *		function has to construct the on disk image to determine its size
  *		and address, this function simply copies the image prepared by
- *		the pre-serialize function into the supplied image buffer, and 
+ *		the pre-serialize function into the supplied image buffer, and
  *		discards a buffer if necessary.
  *
  * Return:	Success:	SUCCEED
@@ -2437,8 +2437,8 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
-H5HF__cache_dblock_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *image, 
+static herr_t
+H5HF__cache_dblock_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *image,
     size_t H5_ATTR_NDEBUG_UNUSED len, void *_thing)
 {
     H5HF_direct_t       *dblock = (H5HF_direct_t *)_thing;      /* Direct block info */
@@ -2462,8 +2462,8 @@ H5HF__cache_dblock_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *image,
     /* Copy the image from *(dblock->write_buf) to *image */
     H5MM_memcpy(image, dblock->write_buf, dblock->write_size);
 
-    /* Free *(dblock->write_buf) if it was allocated by the 
-     * pre-serialize function 
+    /* Free *(dblock->write_buf) if it was allocated by the
+     * pre-serialize function
      */
     if(dblock->write_buf != dblock->blk)
         H5MM_xfree(dblock->write_buf);
@@ -2490,7 +2490,7 @@ H5HF__cache_dblock_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *image,
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_dblock_notify(H5AC_notify_action_t action, void *_thing)
 {
     H5HF_direct_t 	*dblock = (H5HF_direct_t *)_thing;      /* Fractal heap direct block */
@@ -2560,7 +2560,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_dblock_free_icr(void *_thing)
 {
     H5HF_direct_t       *dblock = (H5HF_direct_t *)_thing;      /* Fractal heap direct block */
@@ -2597,7 +2597,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t 
+static herr_t
 H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
 {
     const H5HF_direct_t *dblock = (const H5HF_direct_t *)_thing;      /* Fractal heap direct block */
@@ -2621,9 +2621,9 @@ H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
 /*------------------------------------------------------------------------
  * Function:	H5HF__cache_verify_hdr_descendants_clean
  *
- * Purpose:	Sanity checking routine that verifies that all indirect 
- *		and direct blocks that are descendants of the supplied 
- *		instance of H5HF_hdr_t are clean.  Set *clean to 
+ * Purpose:	Sanity checking routine that verifies that all indirect
+ *		and direct blocks that are descendants of the supplied
+ *		instance of H5HF_hdr_t are clean.  Set *clean to
  *		TRUE if this is the case, and to FALSE otherwise.
  *
  *		Update -- 8/24/15
@@ -2636,41 +2636,41 @@ H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
  *		remain dirty.
  *
  *		To address this, updated the sanity checks in this function
- *		to treat entries whose images are up to date as clean if 
+ *		to treat entries whose images are up to date as clean if
  *		a cache serialization is in progress.
  *
  *		Update -- 9/29/16
  *
  *		The implementation of flush dependencies has been changed.
- *		Prior to this change, a flush dependency parent could be 
+ *		Prior to this change, a flush dependency parent could be
  *		flushed if and only if all its flush dependency descendants
- *		were clean.  In the new definition, a flush dependency 
+ *		were clean.  In the new definition, a flush dependency
  *		parent can be flushed if all its immediate flush dependency
- *		children are clean, regardless of any other dirty 
- *		descendants.  
+ *		children are clean, regardless of any other dirty
+ *		descendants.
  *
- *		Further, metadata cache entries are now allowed to have 
- *		multiple flush dependency parents.  
+ *		Further, metadata cache entries are now allowed to have
+ *		multiple flush dependency parents.
  *
- *		This means that the fractal heap is no longer ncessarily 
+ *		This means that the fractal heap is no longer ncessarily
  *		flushed from the bottom up.
  *
- *		For example, it is now possible for a dirty fractal heap 
+ *		For example, it is now possible for a dirty fractal heap
  *		header to be flushed before a dirty dblock, as long as the
- *		there in an interviening iblock, and the header has no 
+ *		there in an interviening iblock, and the header has no
  *		dirty immediate flush dependency children.
  *
- *		Also, I gather that under some circumstances, a dblock 
- *		will be direct a flush dependency child both of the iblock 
+ *		Also, I gather that under some circumstances, a dblock
+ *		will be direct a flush dependency child both of the iblock
  *		that points to it, and of the fractal heap header.
  *
  *		As a result of these changes, the functionality of these
  *		sanity checking routines has been modified significantly.
  *		Instead of scanning the fractal heap from a starting point
- *		down, and verifying that there were no dirty entries, the 
- *		functions now scan downward from the starting point and 
- *		verify that there are no dirty flush dependency children 
- *		of the specified flush dependency parent.  In passing, 
+ *		down, and verifying that there were no dirty entries, the
+ *		functions now scan downward from the starting point and
+ *		verify that there are no dirty flush dependency children
+ *		of the specified flush dependency parent.  In passing,
  *		they also walk the data structure, and verify it.
  *
  *
@@ -2709,16 +2709,16 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
 
     /* We have three basic scenarios we have to deal with:
      *
-     * The first, and most common case, is that there is a root iblock.  
-     * In this case we need to verify that the root iblock and all its 
+     * The first, and most common case, is that there is a root iblock.
+     * In this case we need to verify that the root iblock and all its
      * children are clean.
      *
-     * The second, and much less common case, is that in which the 
-     * the fractal heap contains only one direct block, which is 
-     * pointed to by hdr->man_dtable.table_addr.  In this case, all we 
+     * The second, and much less common case, is that in which the
+     * the fractal heap contains only one direct block, which is
+     * pointed to by hdr->man_dtable.table_addr.  In this case, all we
      * need to do is verify that the root direct block is clean.
      *
-     * Finally, it is possible that the fractal heap is empty, and 
+     * Finally, it is possible that the fractal heap is empty, and
      * has neither a root indirect block nor a root direct block.
      * In this case, we have nothing to do.
      */
@@ -2726,15 +2726,15 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
     /* There are two ways in which we can arrive at the first scenario.
      *
      * By far the most common is when hdr->root_iblock contains a pointer
-     * to the root iblock -- in this case the root iblock is almost certainly 
+     * to the root iblock -- in this case the root iblock is almost certainly
      * pinned, although we can't count on that.
      *
-     * However, it is also possible that there is a root iblock that 
-     * is no longer pointed to by the header.  In this case, the on 
+     * However, it is also possible that there is a root iblock that
+     * is no longer pointed to by the header.  In this case, the on
      * disk address of the iblock will be in hdr->man_dtable.table_addr
      * and hdr->man_dtable.curr_root_rows will contain a positive value.
      *
-     * Since the former case is far and away the most common, we don't 
+     * Since the former case is far and away the most common, we don't
      * worry too much about efficiency in the second case.
      */
     if(hdr->root_iblock ||
@@ -2748,7 +2748,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
         /* make note of the on disk address of the root iblock */
         if(root_iblock == NULL)
 	    /* hdr->man_dtable.table_addr must contain address of root
-             * iblock.  Check to see if it is in cache.  If it is, 
+             * iblock.  Check to see if it is in cache.  If it is,
              * protect it and put its address in root_iblock.
              */
 	    root_iblock_addr = hdr->man_dtable.table_addr;
@@ -2786,18 +2786,18 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
 
             /* At this point, the root iblock may be pinned, protected,
              * both, or neither, and we may or may not have a pointer
-             * to root iblock in memory.  
+             * to root iblock in memory.
              *
              * Before we call H5HF__cache_verify_iblock_descendants_clean(),
-             * we must ensure that the root iblock is either pinned or 
-             * protected or both, and that we have a pointer to it.  
+             * we must ensure that the root iblock is either pinned or
+             * protected or both, and that we have a pointer to it.
              * Do this as follows:
              */
             if(root_iblock == NULL) {   /* we don't have ptr to root iblock */
                 if(0 == (root_iblock_status & H5AC_ES__IS_PROTECTED)) {
                     /* just protect the root iblock -- this will give us
-                     * the pointer we need to proceed, and ensure that 
-                     * it is locked into the metadata cache for the 
+                     * the pointer we need to proceed, and ensure that
+                     * it is locked into the metadata cache for the
                      * duration.
                      *
                      * Note that the udata is only used in the load callback.
@@ -2808,9 +2808,9 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
                      * The tag specified in the API context we received
                      * as a parameter (via API context) may not be correct.
                      * Grab the (hopefully) correct tag from the header,
-                     * and load it into the API context via the H5_BEGIN_TAG and 
+                     * and load it into the API context via the H5_BEGIN_TAG and
                      * H5_END_TAG macros.  Note that any error bracked by
-                     * these macros must be reported with HGOTO_ERROR_TAG. 
+                     * these macros must be reported with HGOTO_ERROR_TAG.
                      */
                     H5_BEGIN_TAG(hdr->heap_addr)
 
@@ -2825,7 +2825,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
                     /* the root iblock is protected, and we have no
                      * legitimate way of getting a pointer to it.
                      *
-                     * We square this circle by using the 
+                     * We square this circle by using the
                      * H5AC_get_entry_ptr_from_addr() to get the needed
                      * pointer.
                      *
@@ -2846,14 +2846,14 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
                      * be unpinned is if none of its children are in cache.
                      * This unfortunately means that if it is protected and
                      * not pinned, the fractal heap is in the process of loading
-                     * or inserting one of its children.  The obvious 
-                     * implication is that there is a significant chance that 
+                     * or inserting one of its children.  The obvious
+                     * implication is that there is a significant chance that
                      * the root iblock is in an unstable state.
                      *
-                     * All this suggests that using 
-                     * H5AC_get_entry_ptr_from_addr() to obtain the pointer 
-                     * to the protected root iblock is questionable here.  
-                     * However, since this is test/debugging code, I expect 
+                     * All this suggests that using
+                     * H5AC_get_entry_ptr_from_addr() to obtain the pointer
+                     * to the protected root iblock is questionable here.
+                     * However, since this is test/debugging code, I expect
                      * that we will use this approach until it causes problems,
                      *  or we think of a better way.
                      */
@@ -2863,8 +2863,8 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
                 } /* end else */
             } /* end if */
             else {      /* root_iblock != NULL */
-                /* we have the pointer to the root iblock.  Protect it 
-                 * if it is neither pinned nor protected -- otherwise we 
+                /* we have the pointer to the root iblock.  Protect it
+                 * if it is neither pinned nor protected -- otherwise we
                  * are ready to go.
                  */
                  H5HF_indirect_t *   iblock = NULL;
@@ -2882,9 +2882,9 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
                      * The tag associated specified in the API context we received
                      * as a parameter (via API context) may not be correct.
                      * Grab the (hopefully) correct tag from the header,
-                     * and load it into the API context via the H5_BEGIN_TAG and 
+                     * and load it into the API context via the H5_BEGIN_TAG and
                      * H5_END_TAG macros.  Note that any error bracked by
-                     * these macros must be reported with HGOTO_ERROR_TAG. 
+                     * these macros must be reported with HGOTO_ERROR_TAG.
                      */
                     H5_BEGIN_TAG(hdr->heap_addr)
 
@@ -2953,8 +2953,8 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
                 HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "root dblock in cache and is a flush dep parent.")
 
             *clean = !((root_dblock_status & H5AC_ES__IS_DIRTY) &&
-                       (((root_dblock_status & 
-                          H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) || 
+                       (((root_dblock_status &
+                          H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) ||
                         (!H5AC_get_serialization_in_progress(f))));
 
             *fd_clean = *clean;
@@ -2965,8 +2965,8 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
         } /* end else */
     } /* end else-if */
     else {
-        /* this is scenario 3 -- the fractal heap is empty, and we 
-         * have nothing to do. 
+        /* this is scenario 3 -- the fractal heap is empty, and we
+         * have nothing to do.
          */
         *fd_clean = TRUE;
         *clean = TRUE;
@@ -2981,62 +2981,62 @@ done:
 /*------------------------------------------------------------------------
  * Function:	H5HF__cache_verify_iblock_descendants_clean
  *
- * Purpose:	Sanity checking routine that verifies that all indirect 
- *		and direct blocks that are descendants of the supplied 
- *		instance of H5HF_indirect_t are clean.  Set *clean 
+ * Purpose:	Sanity checking routine that verifies that all indirect
+ *		and direct blocks that are descendants of the supplied
+ *		instance of H5HF_indirect_t are clean.  Set *clean
  *		to TRUE if this is the case, and to FALSE otherwise.
  *
- *		In passing, the function also does a cursory check to 
- *		spot any obvious errors in the flush dependency setup.  
- *		If any problems are found, the function returns failure.  
- *		Note that these checks are not exhaustive, thus passing 
- *		them does not mean that the flush dependencies are 
+ *		In passing, the function also does a cursory check to
+ *		spot any obvious errors in the flush dependency setup.
+ *		If any problems are found, the function returns failure.
+ *		Note that these checks are not exhaustive, thus passing
+ *		them does not mean that the flush dependencies are
  *		correct -- only that there is nothing obviously wrong
  *		with them.
  *
- *		WARNING:  At its top level call, this function is 
- *		intended to be called from H5HF_cache_iblock_flush(), 
- *		and thus presumes that the supplied indirect block 
- *		is in cache.  Any other use of this function and 
- *		its descendants must insure that this assumption is 
+ *		WARNING:  At its top level call, this function is
+ *		intended to be called from H5HF_cache_iblock_flush(),
+ *		and thus presumes that the supplied indirect block
+ *		is in cache.  Any other use of this function and
+ *		its descendants must insure that this assumption is
  *		met.
  *
- *		Note that this function and 
- *		H5HF__cache_verify_descendant_iblocks_clean() are 
+ *		Note that this function and
+ *		H5HF__cache_verify_descendant_iblocks_clean() are
  *		recursive co-routines.
  *
  *		Update -- 9/29/16
  *
  *		The implementation of flush dependencies has been changed.
- *		Prior to this change, a flush dependency parent could be 
+ *		Prior to this change, a flush dependency parent could be
  *		flushed if and only if all its flush dependency descendants
- *		were clean.  In the new definition, a flush dependency 
+ *		were clean.  In the new definition, a flush dependency
  *		parent can be flushed if all its immediate flush dependency
- *		children are clean, regardless of any other dirty 
- *		descendants.  
+ *		children are clean, regardless of any other dirty
+ *		descendants.
  *
- *		Further, metadata cache entries are now allowed to have 
- *		multiple flush dependency parents.  
+ *		Further, metadata cache entries are now allowed to have
+ *		multiple flush dependency parents.
  *
- *		This means that the fractal heap is no longer ncessarily 
+ *		This means that the fractal heap is no longer ncessarily
  *		flushed from the bottom up.
  *
- *		For example, it is now possible for a dirty fractal heap 
+ *		For example, it is now possible for a dirty fractal heap
  *		header to be flushed before a dirty dblock, as long as the
- *		there in an interviening iblock, and the header has no 
+ *		there in an interviening iblock, and the header has no
  *		dirty immediate flush dependency children.
  *
- *		Also, I gather that under some circumstances, a dblock 
- *		will be direct a flush dependency child both of the iblock 
+ *		Also, I gather that under some circumstances, a dblock
+ *		will be direct a flush dependency child both of the iblock
  *		that points to it, and of the fractal heap header.
  *
  *		As a result of these changes, the functionality of these
  *		sanity checking routines has been modified significantly.
  *		Instead of scanning the fractal heap from a starting point
- *		down, and verifying that there were no dirty entries, the 
- *		functions now scan downward from the starting point and 
- *		verify that there are no dirty flush dependency children 
- *		of the specified flush dependency parent.  In passing, 
+ *		down, and verifying that there were no dirty entries, the
+ *		functions now scan downward from the starting point and
+ *		verify that there are no dirty flush dependency children
+ *		of the specified flush dependency parent.  In passing,
  *		they also walk the data structure, and verify it.
  *
  * Return:	Non-negative on success/Negative on failure
@@ -3096,17 +3096,17 @@ done:
  *		direct blocks pointed to by the supplied indirect block
  *		are either clean, or not in the cache.
  *
- *		In passing, the function also does a cursory check to 
- *		spot any obvious errors in the flush dependency setup.  
- *		If any problems are found, the function returns failure.  
- *		Note that these checks are not exhaustive, thus passing 
- *		them does not mean that the flush dependencies are 
+ *		In passing, the function also does a cursory check to
+ *		spot any obvious errors in the flush dependency setup.
+ *		If any problems are found, the function returns failure.
+ *		Note that these checks are not exhaustive, thus passing
+ *		them does not mean that the flush dependencies are
  *		correct -- only that there is nothing obviously wrong
  *		with them.
  *
- *		WARNING:  This function presumes that the supplied 
- *		iblock is in the cache, and will not be removed 
- *		during the call.  Caller must ensure that this is 
+ *		WARNING:  This function presumes that the supplied
+ *		iblock is in the cache, and will not be removed
+ *		during the call.  Caller must ensure that this is
  *		the case before the call.
  *
  *      Update -- 8/24/15
@@ -3125,35 +3125,35 @@ done:
  *		Update -- 9/29/16
  *
  *		The implementation of flush dependencies has been changed.
- *		Prior to this change, a flush dependency parent could be 
+ *		Prior to this change, a flush dependency parent could be
  *		flushed if and only if all its flush dependency descendants
- *		were clean.  In the new definition, a flush dependency 
+ *		were clean.  In the new definition, a flush dependency
  *		parent can be flushed if all its immediate flush dependency
- *		children are clean, regardless of any other dirty 
- *		descendants.  
+ *		children are clean, regardless of any other dirty
+ *		descendants.
  *
- *		Further, metadata cache entries are now allowed to have 
- *		multiple flush dependency parents.  
+ *		Further, metadata cache entries are now allowed to have
+ *		multiple flush dependency parents.
  *
- *		This means that the fractal heap is no longer ncessarily 
+ *		This means that the fractal heap is no longer ncessarily
  *		flushed from the bottom up.
  *
- *		For example, it is now possible for a dirty fractal heap 
+ *		For example, it is now possible for a dirty fractal heap
  *		header to be flushed before a dirty dblock, as long as the
- *		there in an interviening iblock, and the header has no 
+ *		there in an interviening iblock, and the header has no
  *		dirty immediate flush dependency children.
  *
- *		Also, I gather that under some circumstances, a dblock 
- *		will be direct a flush dependency child both of the iblock 
+ *		Also, I gather that under some circumstances, a dblock
+ *		will be direct a flush dependency child both of the iblock
  *		that points to it, and of the fractal heap header.
  *
  *		As a result of these changes, the functionality of these
  *		sanity checking routines has been modified significantly.
  *		Instead of scanning the fractal heap from a starting point
- *		down, and verifying that there were no dirty entries, the 
- *		functions now scan downward from the starting point and 
- *		verify that there are no dirty flush dependency children 
- *		of the specified flush dependency parent.  In passing, 
+ *		down, and verifying that there were no dirty entries, the
+ *		functions now scan downward from the starting point and
+ *		verify that there are no dirty flush dependency children
+ *		of the specified flush dependency parent.  In passing,
  *		they also walk the data structure, and verify it.
  *
  * Return:	Non-negative on success/Negative on failure
@@ -3165,8 +3165,8 @@ done:
  */
 #ifndef NDEBUG
 static herr_t
-H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr, 
-    H5HF_indirect_t *iblock, hbool_t *fd_clean, hbool_t *clean, 
+H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
+    H5HF_indirect_t *iblock, hbool_t *fd_clean, hbool_t *clean,
     hbool_t *has_dblocks)
 {
     unsigned	num_direct_rows;
@@ -3224,16 +3224,16 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
                         (((dblock_status & H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) ||
                         (!H5AC_get_serialization_in_progress(f)))) {
                     *clean = FALSE;
-		    
+
                     if(H5AC_flush_dependency_exists(f, fd_parent_addr, dblock_addr, &fd_exists) < 0)
                         HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency")
 
-                    if(fd_exists) 
+                    if(fd_exists)
                         *fd_clean = FALSE;
                 } /* end if */
 
-                /* If a child dblock is in cache, it must have a flush 
-                 * dependency relationship with this iblock.  Test this 
+                /* If a child dblock is in cache, it must have a flush
+                 * dependency relationship with this iblock.  Test this
                  * here.
                  */
                  if(H5AC_flush_dependency_exists(f, iblock_addr, dblock_addr, &fd_exists) < 0)
@@ -3246,7 +3246,7 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
 
         i++;
     } /* end while */
-    
+
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5HF__cache_verify_iblocks_dblocks_clean() */
@@ -3260,17 +3260,17 @@ done:
  *		direct blocks pointed to by the supplied indirect block
  *		are either clean, or not in the cache.
  *
- *		In passing, the function also does a cursory check to 
- *		spot any obvious errors in the flush dependency setup.  
- *		If any problems are found, the function returns failure.  
- *		Note that these checks are not exhaustive, thus passing 
- *		them does not mean that the flush dependencies are 
+ *		In passing, the function also does a cursory check to
+ *		spot any obvious errors in the flush dependency setup.
+ *		If any problems are found, the function returns failure.
+ *		Note that these checks are not exhaustive, thus passing
+ *		them does not mean that the flush dependencies are
  *		correct -- only that there is nothing obviously wrong
  *		with them.
  *
- *		WARNING:  This function presumes that the supplied 
- *		iblock is in the cache, and will not be removed 
- *		during the call.  Caller must ensure that this is 
+ *		WARNING:  This function presumes that the supplied
+ *		iblock is in the cache, and will not be removed
+ *		during the call.  Caller must ensure that this is
  *		the case before the call.
  *
  *              Update -- 8/24/15
@@ -3289,35 +3289,35 @@ done:
  *		Update -- 9/29/16
  *
  *		The implementation of flush dependencies has been changed.
- *		Prior to this change, a flush dependency parent could be 
+ *		Prior to this change, a flush dependency parent could be
  *		flushed if and only if all its flush dependency descendants
- *		were clean.  In the new definition, a flush dependency 
+ *		were clean.  In the new definition, a flush dependency
  *		parent can be flushed if all its immediate flush dependency
- *		children are clean, regardless of any other dirty 
- *		descendants.  
+ *		children are clean, regardless of any other dirty
+ *		descendants.
  *
- *		Further, metadata cache entries are now allowed to have 
+ *		Further, metadata cache entries are now allowed to have
  *		multiple flush dependency parents.
  *
- *		This means that the fractal heap is no longer ncessarily 
+ *		This means that the fractal heap is no longer ncessarily
  *		flushed from the bottom up.
  *
- *		For example, it is now possible for a dirty fractal heap 
+ *		For example, it is now possible for a dirty fractal heap
  *		header to be flushed before a dirty dblock, as long as the
- *		there in an interviening iblock, and the header has no 
+ *		there in an interviening iblock, and the header has no
  *		dirty immediate flush dependency children.
  *
- *		Also, I gather that under some circumstances, a dblock 
- *		will be direct a flush dependency child both of the iblock 
+ *		Also, I gather that under some circumstances, a dblock
+ *		will be direct a flush dependency child both of the iblock
  *		that points to it, and of the fractal heap header.
  *
  *		As a result of these changes, the functionality of these
  *		sanity checking routines has been modified significantly.
  *		Instead of scanning the fractal heap from a starting point
- *		down, and verifying that there were no dirty entries, the 
- *		functions now scan downward from the starting point and 
- *		verify that there are no dirty flush dependency children 
- *		of the specified flush dependency parent.  In passing, 
+ *		down, and verifying that there were no dirty entries, the
+ *		functions now scan downward from the starting point and
+ *		verify that there are no dirty flush dependency children
+ *		of the specified flush dependency parent.  In passing,
  *		they also walk the data structure, and verify it.
  *
  *
@@ -3388,54 +3388,54 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
                         *fd_clean = FALSE;
                 } /* end if */
 
-                /* if the child iblock is in cache and *fd_clean is TRUE, 
+                /* if the child iblock is in cache and *fd_clean is TRUE,
                  * we must continue to explore down the fractal heap tree
-                 * structure to verify that all descendant blocks that are 
-                 * flush dependency children of the entry at parent_addr are 
-                 * either clean, or not in the metadata cache.  We do this 
-                 * with a recursive call to 
+                 * structure to verify that all descendant blocks that are
+                 * flush dependency children of the entry at parent_addr are
+                 * either clean, or not in the metadata cache.  We do this
+                 * with a recursive call to
                  * H5HF__cache_verify_iblock_descendants_clean().
                  * However, we can't make this call unless the child iblock
-                 * is somehow locked into the cache -- typically via either 
+                 * is somehow locked into the cache -- typically via either
                  * pinning or protecting.
                  *
                  * If the child iblock is pinned, we can look up its pointer
-                 * on the current iblock's pinned child iblock list, and 
+                 * on the current iblock's pinned child iblock list, and
                  * and use that pointer in the recursive call.
                  *
                  * If the entry is unprotected and unpinned, we simply
                  * protect it.
                  *
-                 * If, however, the the child iblock is already protected, 
-                 * but not pinned, we have a bit of a problem, as we have 
+                 * If, however, the the child iblock is already protected,
+                 * but not pinned, we have a bit of a problem, as we have
                  * no legitimate way of looking up its pointer in memory.
                  *
                  * To solve this problem, I have added a new metadata cache
-                 * call to obtain the pointer.  
+                 * call to obtain the pointer.
                  *
-                 * WARNING: This call should be used only in debugging 
-                 * 	    routines, and it should be avoided there when 
-                 *	    possible.  
+                 * WARNING: This call should be used only in debugging
+                 * 	    routines, and it should be avoided there when
+                 *	    possible.
                  *
-                 *          Further, if we ever multi-thread the cache, 
-                 *	    this routine will have to be either discarded 
+                 *          Further, if we ever multi-thread the cache,
+                 *	    this routine will have to be either discarded
                  *	    or heavily re-worked.
                  *
-                 *	    Finally, keep in mind that the entry whose 
-                 *	    pointer is obtained in this fashion may not 
-                 *          be in a stable state.  
+                 *	    Finally, keep in mind that the entry whose
+                 *	    pointer is obtained in this fashion may not
+                 *          be in a stable state.
                  *
-                 * Assuming that the flush dependency code is working 
-                 * as it should, the only reason for the child entry to 
+                 * Assuming that the flush dependency code is working
+                 * as it should, the only reason for the child entry to
                  * be unpinned is if none of its children are in cache.
-                 * This unfortunately means that if it is protected and 
+                 * This unfortunately means that if it is protected and
                  * not pinned, the fractal heap is in the process of loading
                  * or inserting one of its children.  The obvious implication
-                 * is that there is a significant chance that the child 
+                 * is that there is a significant chance that the child
                  * iblock is in an unstable state.
                  *
-                 * All this suggests that using the new call to obtain the 
-                 * pointer to the protected child iblock is questionable 
+                 * All this suggests that using the new call to obtain the
+                 * pointer to the protected child iblock is questionable
                  * here.  However, since this is test/debugging code, I
                  * expect that we will use this approach until it causes
                  * problems, or we think of a better way.
@@ -3491,8 +3491,8 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
                         child_iblock = iblock->child_iblocks[i - first_iblock_index];
                     } /* end else */
 
-                    /* At this point, one way or another we should have 
-                     * a pointer to the child iblock.  Verify that we 
+                    /* At this point, one way or another we should have
+                     * a pointer to the child iblock.  Verify that we
                      * that we have the correct one.
                      */
                     HDassert(child_iblock);
@@ -3504,8 +3504,8 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
                     if(H5HF__cache_verify_iblock_descendants_clean(f, fd_parent_addr, child_iblock, &child_iblock_status, fd_clean, clean) < 0)
                         HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify child iblock clean.")
 
-                    /* if iblock_addr != fd_parent_addr, verify that a flush 
-                     * dependency relationship exists between iblock and 
+                    /* if iblock_addr != fd_parent_addr, verify that a flush
+                     * dependency relationship exists between iblock and
                      * the child iblock.
                      */
                     if(fd_parent_addr != iblock_addr) {