Clang-format of source files

1 files changed, 885 insertions, 926 deletions

diff --git a/src/H5Cimage.c b/src/H5Cimage.c
index 41e401e..b3f6c12 100644
--- a/src/H5Cimage.c
+++ b/src/H5Cimage.c
@@ -27,68 +27,64 @@
 /* Module Setup */
 /****************/
 
-#include "H5Cmodule.h"          /* This source code file is part of the H5C module */
-#define H5F_FRIEND		/*suppress error about including H5Fpkg	  */
-
+#include "H5Cmodule.h" /* This source code file is part of the H5C module */
+#define H5F_FRIEND     /*suppress error about including H5Fpkg	  */
 
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
+#include "H5private.h" /* Generic Functions			*/
 #ifdef H5_HAVE_PARALLEL
-#define H5AC_FRIEND		/*suppress error about including H5ACpkg  */
-#include "H5ACpkg.h"            /* Metadata cache                       */
-#endif /* H5_HAVE_PARALLEL */
-#include "H5Cpkg.h"		/* Cache				*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Fpkg.h"		/* Files				*/
-#include "H5FDprivate.h"	/* File drivers				*/
-#include "H5FLprivate.h"	/* Free Lists                           */
-#include "H5MFprivate.h"	/* File memory management		*/
-#include "H5MMprivate.h"	/* Memory management			*/
-
+#define H5AC_FRIEND      /*suppress error about including H5ACpkg  */
+#include "H5ACpkg.h"     /* Metadata cache                       */
+#endif                   /* H5_HAVE_PARALLEL */
+#include "H5Cpkg.h"      /* Cache				*/
+#include "H5Eprivate.h"  /* Error handling		  	*/
+#include "H5Fpkg.h"      /* Files				*/
+#include "H5FDprivate.h" /* File drivers				*/
+#include "H5FLprivate.h" /* Free Lists                           */
+#include "H5MFprivate.h" /* File memory management		*/
+#include "H5MMprivate.h" /* Memory management			*/
 
 /****************/
 /* Local Macros */
 /****************/
 #if H5C_DO_MEMORY_SANITY_CHECKS
-#define H5C_IMAGE_EXTRA_SPACE 8
+#define H5C_IMAGE_EXTRA_SPACE  8
 #define H5C_IMAGE_SANITY_VALUE "DeadBeef"
 #else /* H5C_DO_MEMORY_SANITY_CHECKS */
 #define H5C_IMAGE_EXTRA_SPACE 0
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
 
 /* Cache image buffer components, on disk */
-#define H5C__MDCI_BLOCK_SIGNATURE	"MDCI"
-#define H5C__MDCI_BLOCK_SIGNATURE_LEN	4
-#define H5C__MDCI_BLOCK_VERSION_0	0
+#define H5C__MDCI_BLOCK_SIGNATURE     "MDCI"
+#define H5C__MDCI_BLOCK_SIGNATURE_LEN 4
+#define H5C__MDCI_BLOCK_VERSION_0     0
 
 /* Metadata cache image header flags -- max 8 bits */
-#define H5C__MDCI_HEADER_HAVE_RESIZE_STATUS	0x01
+#define H5C__MDCI_HEADER_HAVE_RESIZE_STATUS 0x01
 
 /* Metadata cache image entry flags -- max 8 bits */
-#define H5C__MDCI_ENTRY_DIRTY_FLAG		0x01
-#define H5C__MDCI_ENTRY_IN_LRU_FLAG		0x02
-#define H5C__MDCI_ENTRY_IS_FD_PARENT_FLAG	0x04
-#define H5C__MDCI_ENTRY_IS_FD_CHILD_FLAG	0x08
+#define H5C__MDCI_ENTRY_DIRTY_FLAG        0x01
+#define H5C__MDCI_ENTRY_IN_LRU_FLAG       0x02
+#define H5C__MDCI_ENTRY_IS_FD_PARENT_FLAG 0x04
+#define H5C__MDCI_ENTRY_IS_FD_CHILD_FLAG  0x08
 
 /* Limits on flush dependency values, stored in 16-bit values on disk */
-#define H5C__MDCI_MAX_FD_CHILDREN		USHRT_MAX
-#define H5C__MDCI_MAX_FD_PARENTS		USHRT_MAX
+#define H5C__MDCI_MAX_FD_CHILDREN USHRT_MAX
+#define H5C__MDCI_MAX_FD_PARENTS  USHRT_MAX
 
 /* Values for image entry magic field */
-#define H5C_IMAGE_ENTRY_T_MAGIC		0x005CAC08
-#define H5C_IMAGE_ENTRY_T_BAD_MAGIC	0xBeefDead
+#define H5C_IMAGE_ENTRY_T_MAGIC     0x005CAC08
+#define H5C_IMAGE_ENTRY_T_BAD_MAGIC 0xBeefDead
 
 /* Maximum ring allowed in image */
-#define H5C_MAX_RING_IN_IMAGE   H5C_RING_MDFSM
-
+#define H5C_MAX_RING_IN_IMAGE H5C_RING_MDFSM
 
 /******************/
 /* Local Typedefs */
 /******************/
 
-
 /********************/
 /* Local Prototypes */
 /********************/
@@ -96,33 +92,27 @@
 /* Helper routines */
 static size_t H5C__cache_image_block_entry_header_size(const H5F_t *f);
 static size_t H5C__cache_image_block_header_size(const H5F_t *f);
-static herr_t H5C__decode_cache_image_header(const H5F_t *f,
-    H5C_t *cache_ptr, const uint8_t **buf);
-#ifndef NDEBUG	/* only used in assertions */
-static herr_t H5C__decode_cache_image_entry(const H5F_t *f,
-    const H5C_t *cache_ptr, const uint8_t **buf, unsigned entry_num);
+static herr_t H5C__decode_cache_image_header(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **buf);
+#ifndef NDEBUG /* only used in assertions */
+static herr_t H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr, const uint8_t **buf,
+                                            unsigned entry_num);
 #endif /* NDEBUG */ /* only used in assertions */
-static herr_t H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr,
-    H5C_cache_entry_t *pf_entry_ptr, H5C_cache_entry_t **fd_children);
-static herr_t H5C__encode_cache_image_header(const H5F_t *f,
-    const H5C_t *cache_ptr, uint8_t **buf);
-static herr_t H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr,
-    uint8_t **buf, unsigned entry_num);
+static herr_t H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr, H5C_cache_entry_t *pf_entry_ptr,
+                                                     H5C_cache_entry_t **fd_children);
+static herr_t H5C__encode_cache_image_header(const H5F_t *f, const H5C_t *cache_ptr, uint8_t **buf);
+static herr_t H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf, unsigned entry_num);
 static herr_t H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr);
-static void H5C__prep_for_file_close__compute_fd_heights_real(
-    H5C_cache_entry_t  *entry_ptr, uint32_t fd_height);
+static void   H5C__prep_for_file_close__compute_fd_heights_real(H5C_cache_entry_t *entry_ptr,
+                                                                uint32_t           fd_height);
 static herr_t H5C__prep_for_file_close__setup_image_entries_array(H5C_t *cache_ptr);
-static herr_t H5C__prep_for_file_close__scan_entries(const H5F_t *f,
-    H5C_t *cache_ptr);
+static herr_t H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr);
 static herr_t H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr);
-static H5C_cache_entry_t *H5C__reconstruct_cache_entry(const H5F_t *f,
-    H5C_t *cache_ptr, const uint8_t **buf);
-static herr_t H5C__write_cache_image_superblock_msg(H5F_t *f, hbool_t create);
-static herr_t H5C__read_cache_image(H5F_t * f, H5C_t *cache_ptr);
-static herr_t H5C__write_cache_image(H5F_t *f, const H5C_t *cache_ptr);
-static herr_t H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr);
-static herr_t H5C__free_image_entries_array(H5C_t *cache_ptr);
-
+static H5C_cache_entry_t *H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **buf);
+static herr_t             H5C__write_cache_image_superblock_msg(H5F_t *f, hbool_t create);
+static herr_t             H5C__read_cache_image(H5F_t *f, H5C_t *cache_ptr);
+static herr_t             H5C__write_cache_image(H5F_t *f, const H5C_t *cache_ptr);
+static herr_t             H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr);
+static herr_t             H5C__free_image_entries_array(H5C_t *cache_ptr);
 
 /*********************/
 /* Package Variables */
@@ -131,17 +121,14 @@ static herr_t H5C__free_image_entries_array(H5C_t *cache_ptr);
 /* Declare a free list to manage H5C_cache_entry_t objects */
 H5FL_DEFINE(H5C_cache_entry_t);
 
-
 /*****************************/
 /* Library Private Variables */
 /*****************************/
 
-
 /*******************/
 /* Local Variables */
 /*******************/
 
-
 /*-------------------------------------------------------------------------
  *
  * Function:    H5C_cache_image_pending()
@@ -162,7 +149,7 @@ H5FL_DEFINE(H5C_cache_entry_t);
 hbool_t
 H5C_cache_image_pending(const H5C_t *cache_ptr)
 {
-    hbool_t             ret_value = TRUE;      /* Return value */
+    hbool_t ret_value = TRUE; /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -175,7 +162,6 @@ H5C_cache_image_pending(const H5C_t *cache_ptr)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C_cache_image_pending() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C_cache_image_status()
  *
@@ -199,9 +185,9 @@ H5C_cache_image_pending(const H5C_t *cache_ptr)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5C_cache_image_status(H5F_t * f, hbool_t *load_ci_ptr, hbool_t *write_ci_ptr)
+H5C_cache_image_status(H5F_t *f, hbool_t *load_ci_ptr, hbool_t *write_ci_ptr)
 {
-    H5C_t *     cache_ptr;
+    H5C_t *cache_ptr;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -214,13 +200,12 @@ H5C_cache_image_status(H5F_t * f, hbool_t *load_ci_ptr, hbool_t *write_ci_ptr)
     HDassert(load_ci_ptr);
     HDassert(write_ci_ptr);
 
-    *load_ci_ptr = cache_ptr->load_image || cache_ptr->image_loaded;
+    *load_ci_ptr  = cache_ptr->load_image || cache_ptr->image_loaded;
     *write_ci_ptr = cache_ptr->image_ctl.generate_image;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5C_cache_image_status() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__construct_cache_image_buffer()
  *
@@ -238,12 +223,12 @@ H5C_cache_image_status(H5F_t * f, hbool_t *load_ci_ptr, hbool_t *write_ci_ptr)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5C__construct_cache_image_buffer(H5F_t * f, H5C_t *cache_ptr)
+H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr)
 {
-    uint8_t *	p;                      /* Pointer into image buffer */
-    uint32_t    chksum;
-    unsigned	u;                      /* Local index variable */
-    herr_t 	ret_value = SUCCEED;    /* Return value */
+    uint8_t *p; /* Pointer into image buffer */
+    uint32_t chksum;
+    unsigned u;                   /* Local index variable */
+    herr_t   ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -261,25 +246,26 @@ H5C__construct_cache_image_buffer(H5F_t * f, H5C_t *cache_ptr)
     HDassert(cache_ptr->image_data_len <= cache_ptr->image_len);
 
     /* Allocate the buffer in which to construct the cache image block */
-    if(NULL == (cache_ptr->image_buffer = H5MM_malloc(cache_ptr->image_len + 1)))
-	HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for cache image buffer")
+    if (NULL == (cache_ptr->image_buffer = H5MM_malloc(cache_ptr->image_len + 1)))
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for cache image buffer")
 
     /* Construct the cache image block header image */
     p = (uint8_t *)cache_ptr->image_buffer;
-    if(H5C__encode_cache_image_header(f, cache_ptr, &p) < 0)
+    if (H5C__encode_cache_image_header(f, cache_ptr, &p) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTENCODE, FAIL, "header image construction failed")
     HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) < cache_ptr->image_data_len);
 
     /* Construct the cache entry images */
-    for(u = 0; u < cache_ptr->num_entries_in_image; u++)
-	if(H5C__encode_cache_image_entry(f, cache_ptr, &p, u) < 0)
+    for (u = 0; u < cache_ptr->num_entries_in_image; u++)
+        if (H5C__encode_cache_image_entry(f, cache_ptr, &p, u) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTENCODE, FAIL, "entry image construction failed")
     HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) < cache_ptr->image_data_len);
 
     /* Construct the adaptive resize status image -- not yet */
 
     /* Compute the checksum and encode */
-    chksum = H5_checksum_metadata(cache_ptr->image_buffer, (size_t)(cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM), 0);
+    chksum = H5_checksum_metadata(cache_ptr->image_buffer,
+                                  (size_t)(cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM), 0);
     UINT32ENCODE(p, chksum);
     HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) == cache_ptr->image_data_len);
     HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) <= cache_ptr->image_len);
@@ -289,92 +275,99 @@ H5C__construct_cache_image_buffer(H5F_t * f, H5C_t *cache_ptr)
      * and comparing the result with the original data.
      */
     {
-        uint32_t        old_chksum;
-        const uint8_t *	q;
-        H5C_t *	        fake_cache_ptr = NULL;
-        unsigned        v;
-        herr_t          status;      /* Status from decoding */
+        uint32_t       old_chksum;
+        const uint8_t *q;
+        H5C_t *        fake_cache_ptr = NULL;
+        unsigned       v;
+        herr_t         status; /* Status from decoding */
 
-	fake_cache_ptr = (H5C_t *)H5MM_malloc(sizeof(H5C_t));
+        fake_cache_ptr = (H5C_t *)H5MM_malloc(sizeof(H5C_t));
         HDassert(fake_cache_ptr);
         fake_cache_ptr->magic = H5C__H5C_T_MAGIC;
 
-	/* needed for sanity checks */
-	fake_cache_ptr->image_len = cache_ptr->image_len;
-        q = (const uint8_t *)cache_ptr->image_buffer;
-        status = H5C__decode_cache_image_header(f, fake_cache_ptr, &q);
+        /* needed for sanity checks */
+        fake_cache_ptr->image_len = cache_ptr->image_len;
+        q                         = (const uint8_t *)cache_ptr->image_buffer;
+        status                    = H5C__decode_cache_image_header(f, fake_cache_ptr, &q);
         HDassert(status >= 0);
 
         HDassert(NULL != p);
         HDassert(fake_cache_ptr->num_entries_in_image == cache_ptr->num_entries_in_image);
 
-	fake_cache_ptr->image_entries = (H5C_image_entry_t *)H5MM_malloc(sizeof(H5C_image_entry_t) *
-                (size_t)(fake_cache_ptr->num_entries_in_image + 1));
-	HDassert(fake_cache_ptr->image_entries);
+        fake_cache_ptr->image_entries = (H5C_image_entry_t *)H5MM_malloc(
+            sizeof(H5C_image_entry_t) * (size_t)(fake_cache_ptr->num_entries_in_image + 1));
+        HDassert(fake_cache_ptr->image_entries);
 
-        for(u = 0; u < fake_cache_ptr->num_entries_in_image; u++) {
-	    (fake_cache_ptr->image_entries)[u].magic = H5C_IMAGE_ENTRY_T_MAGIC;
+        for (u = 0; u < fake_cache_ptr->num_entries_in_image; u++) {
+            (fake_cache_ptr->image_entries)[u].magic     = H5C_IMAGE_ENTRY_T_MAGIC;
             (fake_cache_ptr->image_entries)[u].image_ptr = NULL;
 
-	    /* touch up f->shared->cache to satisfy sanity checks... */
+            /* touch up f->shared->cache to satisfy sanity checks... */
             f->shared->cache = fake_cache_ptr;
-	    status = H5C__decode_cache_image_entry(f, fake_cache_ptr, &q, u);
-	    HDassert(status >= 0);
+            status           = H5C__decode_cache_image_entry(f, fake_cache_ptr, &q, u);
+            HDassert(status >= 0);
 
-	    /* ...and then return f->shared->cache to its correct value */
+            /* ...and then return f->shared->cache to its correct value */
             f->shared->cache = cache_ptr;
 
-	    /* verify expected contents */
-	    HDassert((cache_ptr->image_entries)[u].addr == (fake_cache_ptr->image_entries)[u].addr);
-	    HDassert((cache_ptr->image_entries)[u].size == (fake_cache_ptr->image_entries)[u].size);
-	    HDassert((cache_ptr->image_entries)[u].type_id == (fake_cache_ptr->image_entries)[u].type_id);
-	    HDassert((cache_ptr->image_entries)[u].lru_rank == (fake_cache_ptr->image_entries)[u].lru_rank);
-	    HDassert((cache_ptr->image_entries)[u].is_dirty == (fake_cache_ptr->image_entries)[u].is_dirty);
-	    /* don't check image_fd_height as it is not stored in
+            /* verify expected contents */
+            HDassert((cache_ptr->image_entries)[u].addr == (fake_cache_ptr->image_entries)[u].addr);
+            HDassert((cache_ptr->image_entries)[u].size == (fake_cache_ptr->image_entries)[u].size);
+            HDassert((cache_ptr->image_entries)[u].type_id == (fake_cache_ptr->image_entries)[u].type_id);
+            HDassert((cache_ptr->image_entries)[u].lru_rank == (fake_cache_ptr->image_entries)[u].lru_rank);
+            HDassert((cache_ptr->image_entries)[u].is_dirty == (fake_cache_ptr->image_entries)[u].is_dirty);
+            /* don't check image_fd_height as it is not stored in
              * the metadata cache image block.
              */
-	    HDassert((cache_ptr->image_entries)[u].fd_child_count == (fake_cache_ptr->image_entries)[u].fd_child_count);
-	    HDassert((cache_ptr->image_entries)[u].fd_dirty_child_count == (fake_cache_ptr->image_entries)[u].fd_dirty_child_count);
-	    HDassert((cache_ptr->image_entries)[u].fd_parent_count == (fake_cache_ptr->image_entries)[u].fd_parent_count);
-
-	    for(v = 0; v < (cache_ptr->image_entries)[u].fd_parent_count; v++)
-		HDassert((cache_ptr->image_entries)[u].fd_parent_addrs[v] == (fake_cache_ptr->image_entries)[u].fd_parent_addrs[v]);
-
-	    /* free the fd_parent_addrs array if it exists */
-	    if((fake_cache_ptr->image_entries)[u].fd_parent_addrs) {
-		HDassert((fake_cache_ptr->image_entries)[u].fd_parent_count > 0);
-		(fake_cache_ptr->image_entries)[u].fd_parent_addrs = (haddr_t *)H5MM_xfree((fake_cache_ptr->image_entries)[u].fd_parent_addrs);
-		(fake_cache_ptr->image_entries)[u].fd_parent_count = 0;
-	    } /* end if */
+            HDassert((cache_ptr->image_entries)[u].fd_child_count ==
+                     (fake_cache_ptr->image_entries)[u].fd_child_count);
+            HDassert((cache_ptr->image_entries)[u].fd_dirty_child_count ==
+                     (fake_cache_ptr->image_entries)[u].fd_dirty_child_count);
+            HDassert((cache_ptr->image_entries)[u].fd_parent_count ==
+                     (fake_cache_ptr->image_entries)[u].fd_parent_count);
+
+            for (v = 0; v < (cache_ptr->image_entries)[u].fd_parent_count; v++)
+                HDassert((cache_ptr->image_entries)[u].fd_parent_addrs[v] ==
+                         (fake_cache_ptr->image_entries)[u].fd_parent_addrs[v]);
+
+            /* free the fd_parent_addrs array if it exists */
+            if ((fake_cache_ptr->image_entries)[u].fd_parent_addrs) {
+                HDassert((fake_cache_ptr->image_entries)[u].fd_parent_count > 0);
+                (fake_cache_ptr->image_entries)[u].fd_parent_addrs =
+                    (haddr_t *)H5MM_xfree((fake_cache_ptr->image_entries)[u].fd_parent_addrs);
+                (fake_cache_ptr->image_entries)[u].fd_parent_count = 0;
+            } /* end if */
             else
-		HDassert((fake_cache_ptr->image_entries)[u].fd_parent_count == 0);
+                HDassert((fake_cache_ptr->image_entries)[u].fd_parent_count == 0);
 
-	    HDassert((cache_ptr->image_entries)[u].image_ptr);
+            HDassert((cache_ptr->image_entries)[u].image_ptr);
             HDassert((fake_cache_ptr->image_entries)[u].image_ptr);
             HDassert(!HDmemcmp((cache_ptr->image_entries)[u].image_ptr,
                                (fake_cache_ptr->image_entries)[u].image_ptr,
                                (cache_ptr->image_entries)[u].size));
 
-	    (fake_cache_ptr->image_entries)[u].image_ptr = H5MM_xfree((fake_cache_ptr->image_entries)[u].image_ptr);
-	} /* end for */
+            (fake_cache_ptr->image_entries)[u].image_ptr =
+                H5MM_xfree((fake_cache_ptr->image_entries)[u].image_ptr);
+        } /* end for */
 
-        HDassert((size_t)(q - (const uint8_t *)cache_ptr->image_buffer) == cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM);
+        HDassert((size_t)(q - (const uint8_t *)cache_ptr->image_buffer) ==
+                 cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM);
 
         /* compute the checksum  */
         old_chksum = chksum;
-        chksum = H5_checksum_metadata(cache_ptr->image_buffer, (size_t)(cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM), 0);
-	HDassert(chksum == old_chksum);
+        chksum     = H5_checksum_metadata(cache_ptr->image_buffer,
+                                      (size_t)(cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM), 0);
+        HDassert(chksum == old_chksum);
 
-	fake_cache_ptr->image_entries = (H5C_image_entry_t *)H5MM_xfree(fake_cache_ptr->image_entries);
-	fake_cache_ptr = (H5C_t *)H5MM_xfree(fake_cache_ptr);
-    } /* end block */
+        fake_cache_ptr->image_entries = (H5C_image_entry_t *)H5MM_xfree(fake_cache_ptr->image_entries);
+        fake_cache_ptr                = (H5C_t *)H5MM_xfree(fake_cache_ptr);
+    }  /* end block */
 #endif /* NDEBUG */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__construct_cache_image_buffer() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__generate_cache_image()
  *
@@ -391,7 +384,7 @@ done:
 herr_t
 H5C__generate_cache_image(H5F_t *f, H5C_t *cache_ptr)
 {
-    herr_t 	ret_value = SUCCEED;    /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -403,16 +396,16 @@ H5C__generate_cache_image(H5F_t *f, H5C_t *cache_ptr)
     HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
 
     /* Construct cache image */
-    if(H5C__construct_cache_image_buffer(f, cache_ptr) < 0)
+    if (H5C__construct_cache_image_buffer(f, cache_ptr) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't create metadata cache image")
 
     /* Free image entries array */
-    if(H5C__free_image_entries_array(cache_ptr) < 0)
+    if (H5C__free_image_entries_array(cache_ptr) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't free image entries array")
 
     /* Write cache image block if so configured */
-    if(cache_ptr->image_ctl.flags & H5C_CI__GEN_MDC_IMAGE_BLK) {
-        if(H5C__write_cache_image(f, cache_ptr) < 0)
+    if (cache_ptr->image_ctl.flags & H5C_CI__GEN_MDC_IMAGE_BLK) {
+        if (H5C__write_cache_image(f, cache_ptr) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't write metadata cache image block to file")
 
         H5C__UPDATE_STATS_FOR_CACHE_IMAGE_CREATE(cache_ptr);
@@ -426,7 +419,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__generate_cache_image() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__deserialize_prefetched_entry()
  *
@@ -461,36 +453,34 @@ done:
  *
  * Programmer:  John Mainzer, 8/10/15
  *
- * Changes:     Updated sanity checks for possibility that the slist 
+ * Changes:     Updated sanity checks for possibility that the slist
  *              is disabled.
  *                                            JRM -- 5/17/20
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
-    H5C_cache_entry_t **entry_ptr_ptr, const H5C_class_t *type,
-    haddr_t addr, void *udata)
+H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t **entry_ptr_ptr,
+                                  const H5C_class_t *type, haddr_t addr, void *udata)
 {
-    hbool_t             dirty = FALSE;  /* Flag indicating whether thing was
-                                         * dirtied during deserialize
-                                         */
-    size_t              len;            /* Size of image in file */
-    void *              thing = NULL;   /* Pointer to thing loaded */
-    H5C_cache_entry_t * pf_entry_ptr;   /* pointer to the prefetched entry   */
-                                        /* supplied in *entry_ptr_ptr.       */
-    H5C_cache_entry_t *	ds_entry_ptr;   /* Alias for thing loaded, as cache
-                                         * entry
-                                         */
-    H5C_cache_entry_t** fd_children = NULL; /* Pointer to a dynamically      */
-                                        /* allocated array of pointers to    */
-                                        /* the flush dependency children of  */
-                                        /* the prefetched entry, or NULL if  */
-                                        /* that array does not exist.        */
-    unsigned            flush_flags = (H5C__FLUSH_INVALIDATE_FLAG |
-                                       H5C__FLUSH_CLEAR_ONLY_FLAG);
-    int                 i;
-    herr_t      	ret_value = SUCCEED;      /* Return value */
+    hbool_t dirty = FALSE;                  /* Flag indicating whether thing was
+                                             * dirtied during deserialize
+                                             */
+    size_t             len;                 /* Size of image in file */
+    void *             thing = NULL;        /* Pointer to thing loaded */
+    H5C_cache_entry_t *pf_entry_ptr;        /* pointer to the prefetched entry   */
+                                            /* supplied in *entry_ptr_ptr.       */
+    H5C_cache_entry_t *ds_entry_ptr;        /* Alias for thing loaded, as cache
+                                             * entry
+                                             */
+    H5C_cache_entry_t **fd_children = NULL; /* Pointer to a dynamically      */
+                                            /* allocated array of pointers to    */
+                                            /* the flush dependency children of  */
+                                            /* the prefetched entry, or NULL if  */
+                                            /* that array does not exist.        */
+    unsigned flush_flags = (H5C__FLUSH_INVALIDATE_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG);
+    int      i;
+    herr_t   ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -521,8 +511,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
     /* Can't see how skip reads could be usefully combined with
      * either the speculative read flag.  Hence disallow.
      */
-    HDassert(!((type->flags & H5C__CLASS_SKIP_READS) &&
-               (type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG)));
+    HDassert(!((type->flags & H5C__CLASS_SKIP_READS) && (type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG)));
     HDassert(H5F_addr_defined(addr));
     HDassert(type->get_initial_load_size);
     HDassert(type->deserialize);
@@ -532,7 +521,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
      * the deserialized entry if appropriate.
      */
     HDassert(pf_entry_ptr->fd_parent_count == pf_entry_ptr->flush_dep_nparents);
-    for(i = (int)(pf_entry_ptr->fd_parent_count) - 1; i >= 0; i--) {
+    for (i = (int)(pf_entry_ptr->fd_parent_count) - 1; i >= 0; i--) {
         HDassert(pf_entry_ptr->flush_dep_parent);
         HDassert(pf_entry_ptr->flush_dep_parent[i]);
         HDassert(pf_entry_ptr->flush_dep_parent[i]->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
@@ -540,7 +529,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
         HDassert(pf_entry_ptr->fd_parent_addrs);
         HDassert(pf_entry_ptr->flush_dep_parent[i]->addr == pf_entry_ptr->fd_parent_addrs[i]);
 
-        if(H5C_destroy_flush_dependency(pf_entry_ptr->flush_dep_parent[i], pf_entry_ptr) < 0)
+        if (H5C_destroy_flush_dependency(pf_entry_ptr->flush_dep_parent[i], pf_entry_ptr) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "can't destroy pf entry parent flush dependency")
 
         pf_entry_ptr->fd_parent_addrs[i] = HADDR_UNDEF;
@@ -557,12 +546,14 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
      * pointers to the flush dependency children of *pf_enty_ptr for later
      * use.
      */
-    if(pf_entry_ptr->fd_child_count > 0) {
-        if(NULL == (fd_children = (H5C_cache_entry_t **)H5MM_calloc(sizeof(H5C_cache_entry_t **) * (size_t)(pf_entry_ptr->fd_child_count + 1))))
+    if (pf_entry_ptr->fd_child_count > 0) {
+        if (NULL == (fd_children = (H5C_cache_entry_t **)H5MM_calloc(
+                         sizeof(H5C_cache_entry_t **) * (size_t)(pf_entry_ptr->fd_child_count + 1))))
             HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for fd child ptr array")
 
-        if(H5C__destroy_pf_entry_child_flush_deps(cache_ptr, pf_entry_ptr, fd_children) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "can't destroy pf entry child flush dependency(s).")
+        if (H5C__destroy_pf_entry_child_flush_deps(cache_ptr, pf_entry_ptr, fd_children) < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL,
+                        "can't destroy pf entry child flush dependency(s).")
     } /* end if */
 
     /* Since the size of the on disk image is known exactly, there is
@@ -576,7 +567,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
     /* Deserialize the prefetched on-disk image of the entry into the
      * native memory form
      */
-    if(NULL == (thing = type->deserialize(pf_entry_ptr->image_ptr, len, udata, &dirty)))
+    if (NULL == (thing = type->deserialize(pf_entry_ptr->image_ptr, len, udata, &dirty)))
         HGOTO_ERROR(H5E_CACHE, H5E_CANTLOAD, FAIL, "Can't deserialize image")
     ds_entry_ptr = (H5C_cache_entry_t *)thing;
 
@@ -606,33 +597,33 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
      * hence the value assigned to ds_entry_ptr->is_dirty below.
      */
 
-    HDassert( ( dirty == FALSE ) || ( type->id == 5 || type->id == 6) );
+    HDassert((dirty == FALSE) || (type->id == 5 || type->id == 6));
 
-    ds_entry_ptr->magic                     = H5C__H5C_CACHE_ENTRY_T_MAGIC;
-    ds_entry_ptr->cache_ptr                 = f->shared->cache;
-    ds_entry_ptr->addr                      = addr;
-    ds_entry_ptr->size                      = len;
+    ds_entry_ptr->magic     = H5C__H5C_CACHE_ENTRY_T_MAGIC;
+    ds_entry_ptr->cache_ptr = f->shared->cache;
+    ds_entry_ptr->addr      = addr;
+    ds_entry_ptr->size      = len;
     HDassert(ds_entry_ptr->size < H5C_MAX_ENTRY_SIZE);
-    ds_entry_ptr->image_ptr                 = pf_entry_ptr->image_ptr;
-    ds_entry_ptr->image_up_to_date          = !dirty;
-    ds_entry_ptr->type                      = type;
-    ds_entry_ptr->is_dirty	                = dirty | pf_entry_ptr->is_dirty;
-    ds_entry_ptr->dirtied                   = FALSE;
-    ds_entry_ptr->is_protected              = FALSE;
-    ds_entry_ptr->is_read_only              = FALSE;
-    ds_entry_ptr->ro_ref_count              = 0;
-    ds_entry_ptr->is_pinned                 = FALSE;
-    ds_entry_ptr->in_slist                  = FALSE;
-    ds_entry_ptr->flush_marker              = FALSE;
+    ds_entry_ptr->image_ptr        = pf_entry_ptr->image_ptr;
+    ds_entry_ptr->image_up_to_date = !dirty;
+    ds_entry_ptr->type             = type;
+    ds_entry_ptr->is_dirty         = dirty | pf_entry_ptr->is_dirty;
+    ds_entry_ptr->dirtied          = FALSE;
+    ds_entry_ptr->is_protected     = FALSE;
+    ds_entry_ptr->is_read_only     = FALSE;
+    ds_entry_ptr->ro_ref_count     = 0;
+    ds_entry_ptr->is_pinned        = FALSE;
+    ds_entry_ptr->in_slist         = FALSE;
+    ds_entry_ptr->flush_marker     = FALSE;
 #ifdef H5_HAVE_PARALLEL
-    ds_entry_ptr->clear_on_unprotect        = FALSE;
-    ds_entry_ptr->flush_immediately         = FALSE;
-    ds_entry_ptr->coll_access               = FALSE;
+    ds_entry_ptr->clear_on_unprotect = FALSE;
+    ds_entry_ptr->flush_immediately  = FALSE;
+    ds_entry_ptr->coll_access        = FALSE;
 #endif /* H5_HAVE_PARALLEL */
-    ds_entry_ptr->flush_in_progress         = FALSE;
-    ds_entry_ptr->destroy_in_progress       = FALSE;
+    ds_entry_ptr->flush_in_progress   = FALSE;
+    ds_entry_ptr->destroy_in_progress = FALSE;
 
-    ds_entry_ptr->ring                      = pf_entry_ptr->ring;
+    ds_entry_ptr->ring = pf_entry_ptr->ring;
 
     /* Initialize flush dependency height fields */
     ds_entry_ptr->flush_dep_parent          = NULL;
@@ -643,44 +634,44 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
     ds_entry_ptr->flush_dep_nunser_children = 0;
 
     /* Initialize fields supporting the hash table: */
-    ds_entry_ptr->ht_next                   = NULL;
-    ds_entry_ptr->ht_prev                   = NULL;
-    ds_entry_ptr->il_next                   = NULL;
-    ds_entry_ptr->il_prev                   = NULL;
+    ds_entry_ptr->ht_next = NULL;
+    ds_entry_ptr->ht_prev = NULL;
+    ds_entry_ptr->il_next = NULL;
+    ds_entry_ptr->il_prev = NULL;
 
     /* Initialize fields supporting replacement policies: */
-    ds_entry_ptr->next                      = NULL;
-    ds_entry_ptr->prev                      = NULL;
+    ds_entry_ptr->next = NULL;
+    ds_entry_ptr->prev = NULL;
 #if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
-    ds_entry_ptr->aux_next                  = NULL;
-    ds_entry_ptr->aux_prev                  = NULL;
+    ds_entry_ptr->aux_next = NULL;
+    ds_entry_ptr->aux_prev = NULL;
 #endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
 #ifdef H5_HAVE_PARALLEL
-    pf_entry_ptr->coll_next                 = NULL;
-    pf_entry_ptr->coll_prev                 = NULL;
+    pf_entry_ptr->coll_next = NULL;
+    pf_entry_ptr->coll_prev = NULL;
 #endif /* H5_HAVE_PARALLEL */
 
     /* Initialize cache image related fields */
-    ds_entry_ptr->include_in_image          = FALSE;
-    ds_entry_ptr->lru_rank	                = 0;
-    ds_entry_ptr->image_dirty	             = FALSE;
-    ds_entry_ptr->fd_parent_count           = 0;
-    ds_entry_ptr->fd_parent_addrs           = NULL;
-    ds_entry_ptr->fd_child_count            = pf_entry_ptr->fd_child_count;
-    ds_entry_ptr->fd_dirty_child_count      = 0;
-    ds_entry_ptr->image_fd_height           = 0;
-    ds_entry_ptr->prefetched	              = FALSE;
-    ds_entry_ptr->prefetch_type_id          = 0;
-    ds_entry_ptr->age                       = 0;
-    ds_entry_ptr->prefetched_dirty          = pf_entry_ptr->prefetched_dirty;
-#ifndef NDEBUG  /* debugging field */
-    ds_entry_ptr->serialization_count       = 0;
+    ds_entry_ptr->include_in_image     = FALSE;
+    ds_entry_ptr->lru_rank             = 0;
+    ds_entry_ptr->image_dirty          = FALSE;
+    ds_entry_ptr->fd_parent_count      = 0;
+    ds_entry_ptr->fd_parent_addrs      = NULL;
+    ds_entry_ptr->fd_child_count       = pf_entry_ptr->fd_child_count;
+    ds_entry_ptr->fd_dirty_child_count = 0;
+    ds_entry_ptr->image_fd_height      = 0;
+    ds_entry_ptr->prefetched           = FALSE;
+    ds_entry_ptr->prefetch_type_id     = 0;
+    ds_entry_ptr->age                  = 0;
+    ds_entry_ptr->prefetched_dirty     = pf_entry_ptr->prefetched_dirty;
+#ifndef NDEBUG /* debugging field */
+    ds_entry_ptr->serialization_count = 0;
 #endif /* NDEBUG */
 
     H5C__RESET_CACHE_ENTRY_STATS(ds_entry_ptr);
 
     /* Apply to to the newly deserialized entry */
-    if(H5C__tag_entry(cache_ptr, ds_entry_ptr) < 0)
+    if (H5C__tag_entry(cache_ptr, ds_entry_ptr) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTTAG, FAIL, "Cannot tag metadata entry")
 
     /* We have successfully deserialized the prefetched entry.
@@ -705,16 +696,16 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
      */
     pf_entry_ptr->image_ptr = NULL;
 
-    if ( pf_entry_ptr->is_dirty ) {
+    if (pf_entry_ptr->is_dirty) {
 
-        HDassert(((cache_ptr->slist_enabled) && (pf_entry_ptr->in_slist)) || \
+        HDassert(((cache_ptr->slist_enabled) && (pf_entry_ptr->in_slist)) ||
                  ((!cache_ptr->slist_enabled) && (!pf_entry_ptr->in_slist)));
 
         flush_flags |= H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG;
 
     } /* end if */
 
-    if(H5C__flush_single_entry(f, pf_entry_ptr, flush_flags) < 0)
+    if (H5C__flush_single_entry(f, pf_entry_ptr, flush_flags) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTEXPUNGE, FAIL, "can't expunge prefetched entry")
 
 #ifndef NDEGUG /* verify deletion */
@@ -727,7 +718,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
     H5C__INSERT_IN_INDEX(cache_ptr, ds_entry_ptr, FAIL)
 
     HDassert(!ds_entry_ptr->in_slist);
-    if(ds_entry_ptr->is_dirty)
+    if (ds_entry_ptr->is_dirty)
         H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, ds_entry_ptr, FAIL)
 
     H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, ds_entry_ptr, FAIL)
@@ -737,8 +728,8 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
      * send an "after load" notice now that the deserialized entry is fully
      * integrated into the cache.
      */
-    if(ds_entry_ptr->type->notify &&
-            (ds_entry_ptr->type->notify)(H5C_NOTIFY_ACTION_AFTER_LOAD, ds_entry_ptr) < 0)
+    if (ds_entry_ptr->type->notify &&
+        (ds_entry_ptr->type->notify)(H5C_NOTIFY_ACTION_AFTER_LOAD, ds_entry_ptr) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTNOTIFY, FAIL, "can't notify client about entry loaded into cache")
 
     /* Restore flush dependencies with the flush dependency children of
@@ -747,10 +738,10 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
      * then unprotect it afterwards.
      */
     i = 0;
-    if(fd_children != NULL) {
+    if (fd_children != NULL) {
         H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, ds_entry_ptr, FAIL)
         ds_entry_ptr->is_protected = TRUE;
-        while(fd_children[i] != NULL) {
+        while (fd_children[i] != NULL) {
             /* Sanity checks */
             HDassert((fd_children[i])->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
             HDassert((fd_children[i])->prefetched);
@@ -759,13 +750,13 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
 
 #ifndef NDEBUG
             {
-                int j;
+                int     j;
                 hbool_t found;
 
-                j = 0;
+                j     = 0;
                 found = FALSE;
-                while((j < (int)((fd_children[i])->fd_parent_count)) && (!found)) {
-                    if((fd_children[i])->fd_parent_addrs[j] == ds_entry_ptr->addr)
+                while ((j < (int)((fd_children[i])->fd_parent_count)) && (!found)) {
+                    if ((fd_children[i])->fd_parent_addrs[j] == ds_entry_ptr->addr)
                         found = TRUE;
 
                     j++;
@@ -774,7 +765,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
             }
 #endif /* NDEBUG */
 
-            if(H5C_create_flush_dependency(ds_entry_ptr, fd_children[i]) < 0)
+            if (H5C_create_flush_dependency(ds_entry_ptr, fd_children[i]) < 0)
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTDEPEND, FAIL, "Can't restore child flush dependency")
 
             i++;
@@ -792,18 +783,17 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
     *entry_ptr_ptr = ds_entry_ptr;
 
 done:
-    if(fd_children)
+    if (fd_children)
         fd_children = (H5C_cache_entry_t **)H5MM_xfree((void *)fd_children);
 
     /* Release resources on error */
-    if(FAIL == ret_value)
-        if(thing && type->free_icr(thing) < 0)
+    if (FAIL == ret_value)
+        if (thing && type->free_icr(thing) < 0)
             HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "free_icr callback failed")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__deserialize_prefetched_entry() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__free_image_entries_array
  *
@@ -822,7 +812,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5C__free_image_entries_array(H5C_t * cache_ptr)
+H5C__free_image_entries_array(H5C_t *cache_ptr)
 {
     FUNC_ENTER_STATIC_NOERR
 
@@ -834,44 +824,43 @@ H5C__free_image_entries_array(H5C_t * cache_ptr)
     HDassert(cache_ptr->index_len == 0);
 
     /* Check for entries to free */
-    if(cache_ptr->image_entries != NULL) {
-        unsigned u;     /* Local index variable */
+    if (cache_ptr->image_entries != NULL) {
+        unsigned u; /* Local index variable */
 
-        for(u = 0; u < cache_ptr->num_entries_in_image; u++) {
-            H5C_image_entry_t *ie_ptr;          /* Image entry to release */
+        for (u = 0; u < cache_ptr->num_entries_in_image; u++) {
+            H5C_image_entry_t *ie_ptr; /* Image entry to release */
 
             /* Get pointer to image entry */
- 	    ie_ptr = &((cache_ptr->image_entries)[u]);
+            ie_ptr = &((cache_ptr->image_entries)[u]);
 
             /* Sanity checks */
-	    HDassert(ie_ptr);
+            HDassert(ie_ptr);
             HDassert(ie_ptr->magic == H5C_IMAGE_ENTRY_T_MAGIC);
-	    HDassert(ie_ptr->image_ptr);
+            HDassert(ie_ptr->image_ptr);
 
-	    /* Free the parent addrs array if appropriate */
-	    if(ie_ptr->fd_parent_addrs) {
-		HDassert(ie_ptr->fd_parent_count > 0);
+            /* Free the parent addrs array if appropriate */
+            if (ie_ptr->fd_parent_addrs) {
+                HDassert(ie_ptr->fd_parent_count > 0);
 
-		ie_ptr->fd_parent_addrs = (haddr_t *)H5MM_xfree(ie_ptr->fd_parent_addrs);
+                ie_ptr->fd_parent_addrs = (haddr_t *)H5MM_xfree(ie_ptr->fd_parent_addrs);
             } /* end if */
             else
-		HDassert(ie_ptr->fd_parent_count == 0);
+                HDassert(ie_ptr->fd_parent_count == 0);
 
             /* Free the image */
             ie_ptr->image_ptr = H5MM_xfree(ie_ptr->image_ptr);
 
-	    /* Set magic field to bad magic so we can detect freed entries */
-	    ie_ptr->magic = H5C_IMAGE_ENTRY_T_BAD_MAGIC;
-	} /* end for */
+            /* Set magic field to bad magic so we can detect freed entries */
+            ie_ptr->magic = H5C_IMAGE_ENTRY_T_BAD_MAGIC;
+        } /* end for */
 
-	/* Free the image entries array */
-	cache_ptr->image_entries = (H5C_image_entry_t *)H5MM_xfree(cache_ptr->image_entries);
+        /* Free the image entries array */
+        cache_ptr->image_entries = (H5C_image_entry_t *)H5MM_xfree(cache_ptr->image_entries);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5C__free_image_entries_array() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C_get_cache_image_config
  *
@@ -887,16 +876,15 @@ H5C__free_image_entries_array(H5C_t * cache_ptr)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5C_get_cache_image_config(const H5C_t * cache_ptr,
-    H5C_cache_image_ctl_t *config_ptr)
+H5C_get_cache_image_config(const H5C_t *cache_ptr, H5C_cache_image_ctl_t *config_ptr)
 {
-    herr_t ret_value = SUCCEED;      /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    if((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC))
+    if ((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC))
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad cache_ptr on entry")
-    if(config_ptr == NULL)
+    if (config_ptr == NULL)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad config_ptr on entry")
 
     *config_ptr = cache_ptr->image_ctl;
@@ -905,7 +893,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C_get_cache_image_config() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C_image_stats
  *
@@ -920,66 +907,59 @@ done:
  */
 herr_t
 #if H5C_COLLECT_CACHE_STATS
-H5C_image_stats(H5C_t * cache_ptr, hbool_t print_header)
-#else /* H5C_COLLECT_CACHE_STATS */
-H5C_image_stats(H5C_t * cache_ptr, hbool_t H5_ATTR_UNUSED print_header)
+H5C_image_stats(H5C_t *cache_ptr, hbool_t print_header)
+#else  /* H5C_COLLECT_CACHE_STATS */
+H5C_image_stats(H5C_t *cache_ptr, hbool_t H5_ATTR_UNUSED print_header)
 #endif /* H5C_COLLECT_CACHE_STATS */
 {
 #if H5C_COLLECT_CACHE_STATS
-    int         i;
-    int64_t     total_hits = 0;
-    int64_t     total_misses = 0;
-    double      hit_rate;
-    double      prefetch_use_rate;
-#endif /* H5C_COLLECT_CACHE_STATS */
-    herr_t      ret_value = SUCCEED;   /* Return value */
+    int     i;
+    int64_t total_hits   = 0;
+    int64_t total_misses = 0;
+    double  hit_rate;
+    double  prefetch_use_rate;
+#endif                          /* H5C_COLLECT_CACHE_STATS */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    if(!cache_ptr || cache_ptr->magic != H5C__H5C_T_MAGIC)
+    if (!cache_ptr || cache_ptr->magic != H5C__H5C_T_MAGIC)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr")
 
 #if H5C_COLLECT_CACHE_STATS
-    for(i = 0; i <= cache_ptr->max_type_id; i++) {
-        total_hits              += cache_ptr->hits[i];
-        total_misses            += cache_ptr->misses[i];
+    for (i = 0; i <= cache_ptr->max_type_id; i++) {
+        total_hits += cache_ptr->hits[i];
+        total_misses += cache_ptr->misses[i];
     } /* end for */
 
-    if((total_hits > 0) || (total_misses > 0))
+    if ((total_hits > 0) || (total_misses > 0))
         hit_rate = (double)100.0f * ((double)(total_hits)) / ((double)(total_hits + total_misses));
     else
         hit_rate = 0.0f;
 
-    if(cache_ptr->prefetches > 0)
-        prefetch_use_rate = (double)100.0f * ((double)(cache_ptr->prefetch_hits)) /
-                   ((double)(cache_ptr->prefetches));
+    if (cache_ptr->prefetches > 0)
+        prefetch_use_rate =
+            (double)100.0f * ((double)(cache_ptr->prefetch_hits)) / ((double)(cache_ptr->prefetches));
     else
         prefetch_use_rate = 0.0f;
 
-    if(print_header) {
-        HDfprintf(stdout,
-           "\nhit     prefetches      prefetch              image  pf hit\n");
-        HDfprintf(stdout,
-             "rate:   total:  dirty:  hits:  flshs:  evct:  size:  rate:\n");
+    if (print_header) {
+        HDfprintf(stdout, "\nhit     prefetches      prefetch              image  pf hit\n");
+        HDfprintf(stdout, "rate:   total:  dirty:  hits:  flshs:  evct:  size:  rate:\n");
     } /* end if */
 
-    HDfprintf(stdout,
-           "%3.1lf    %5lld   %5lld   %5lld  %5lld   %5lld   %5lld   %3.1lf\n",
-            hit_rate,
-            (long long)(cache_ptr->prefetches),
-            (long long)(cache_ptr->dirty_prefetches),
-            (long long)(cache_ptr->prefetch_hits),
-            (long long)(cache_ptr->flushes[H5AC_PREFETCHED_ENTRY_ID]),
-            (long long)(cache_ptr->evictions[H5AC_PREFETCHED_ENTRY_ID]),
-            (long long)(cache_ptr->last_image_size),
-            prefetch_use_rate);
+    HDfprintf(stdout, "%3.1lf    %5lld   %5lld   %5lld  %5lld   %5lld   %5lld   %3.1lf\n", hit_rate,
+              (long long)(cache_ptr->prefetches), (long long)(cache_ptr->dirty_prefetches),
+              (long long)(cache_ptr->prefetch_hits),
+              (long long)(cache_ptr->flushes[H5AC_PREFETCHED_ENTRY_ID]),
+              (long long)(cache_ptr->evictions[H5AC_PREFETCHED_ENTRY_ID]),
+              (long long)(cache_ptr->last_image_size), prefetch_use_rate);
 #endif /* H5C_COLLECT_CACHE_STATS */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C_image_stats() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__read_cache_image
  *
@@ -996,7 +976,7 @@ done:
 static herr_t
 H5C__read_cache_image(H5F_t *f, H5C_t *cache_ptr)
 {
-    herr_t              ret_value = SUCCEED;    /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -1008,55 +988,48 @@ H5C__read_cache_image(H5F_t *f, H5C_t *cache_ptr)
     HDassert(cache_ptr->image_buffer);
 
 #ifdef H5_HAVE_PARALLEL
-{
-    H5AC_aux_t *aux_ptr = (H5AC_aux_t *)cache_ptr->aux_ptr;
-    int mpi_result;
+    {
+        H5AC_aux_t *aux_ptr = (H5AC_aux_t *)cache_ptr->aux_ptr;
+        int         mpi_result;
 
-    if ( ( NULL == aux_ptr ) || ( aux_ptr->mpi_rank == 0 ) ) {
+        if ((NULL == aux_ptr) || (aux_ptr->mpi_rank == 0)) {
 
-	HDassert((NULL == aux_ptr) ||
-                 (aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC));
+            HDassert((NULL == aux_ptr) || (aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC));
 #endif /* H5_HAVE_PARALLEL */
 
-	/* Read the buffer (if serial access, or rank 0 of parallel access) */
-        if(H5F_block_read(f, H5FD_MEM_SUPER, cache_ptr->image_addr,
-                cache_ptr->image_len, cache_ptr->image_buffer) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_READERROR, FAIL, "Can't read metadata cache image block")
+            /* Read the buffer (if serial access, or rank 0 of parallel access) */
+            if (H5F_block_read(f, H5FD_MEM_SUPER, cache_ptr->image_addr, cache_ptr->image_len,
+                               cache_ptr->image_buffer) < 0)
+                HGOTO_ERROR(H5E_CACHE, H5E_READERROR, FAIL, "Can't read metadata cache image block")
 
-        H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ(cache_ptr)
+            H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ(cache_ptr)
 
 #ifdef H5_HAVE_PARALLEL
-        if ( aux_ptr ) {
+            if (aux_ptr) {
 
-	        /* Broadcast cache image */
-            if ( MPI_SUCCESS !=
-                 (mpi_result = MPI_Bcast(cache_ptr->image_buffer,
-                                         (int)cache_ptr->image_len, MPI_BYTE,
-                                         0, aux_ptr->mpi_comm)) )
+                /* Broadcast cache image */
+                if (MPI_SUCCESS != (mpi_result = MPI_Bcast(cache_ptr->image_buffer, (int)cache_ptr->image_len,
+                                                           MPI_BYTE, 0, aux_ptr->mpi_comm)))
 
-                HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", mpi_result)
+                    HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", mpi_result)
 
-        } /* end if */
-    } /* end if */
-    else if ( aux_ptr ) {
-
-        /* Retrieve the contents of the metadata cache image from process 0 */
-        if ( MPI_SUCCESS !=
-             (mpi_result = MPI_Bcast(cache_ptr->image_buffer,
-                                     (int)cache_ptr->image_len, MPI_BYTE,
-                                     0, aux_ptr->mpi_comm)) )
-
-            HMPI_GOTO_ERROR(FAIL, "can't receive cache image MPI_Bcast", \
-                            mpi_result)
-    } /* end else-if */
-} /* end block */
-#endif /* H5_HAVE_PARALLEL */
+            } /* end if */
+        }     /* end if */
+        else if (aux_ptr) {
+
+            /* Retrieve the contents of the metadata cache image from process 0 */
+            if (MPI_SUCCESS != (mpi_result = MPI_Bcast(cache_ptr->image_buffer, (int)cache_ptr->image_len,
+                                                       MPI_BYTE, 0, aux_ptr->mpi_comm)))
+
+                HMPI_GOTO_ERROR(FAIL, "can't receive cache image MPI_Bcast", mpi_result)
+        } /* end else-if */
+    }     /* end block */
+#endif    /* H5_HAVE_PARALLEL */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__read_cache_image() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__load_cache_image
  *
@@ -1077,8 +1050,8 @@ done:
 herr_t
 H5C__load_cache_image(H5F_t *f)
 {
-    H5C_t *             cache_ptr;
-    herr_t		ret_value = SUCCEED;    /* Return value */
+    H5C_t *cache_ptr;
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -1098,21 +1071,21 @@ H5C__load_cache_image(H5F_t *f)
      * no image exists, and that the load operation should be skipped
      * silently.
      */
-    if(H5F_addr_defined(cache_ptr->image_addr)) {
+    if (H5F_addr_defined(cache_ptr->image_addr)) {
         /* Sanity checks */
         HDassert(cache_ptr->image_len > 0);
         HDassert(cache_ptr->image_buffer == NULL);
 
         /* Allocate space for the image */
-        if(NULL == (cache_ptr->image_buffer = H5MM_malloc(cache_ptr->image_len + 1)))
+        if (NULL == (cache_ptr->image_buffer = H5MM_malloc(cache_ptr->image_len + 1)))
             HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for cache image buffer")
 
         /* Load the image from file */
-        if(H5C__read_cache_image(f, cache_ptr) < 0)
+        if (H5C__read_cache_image(f, cache_ptr) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_READERROR, FAIL, "Can't read metadata cache image block")
 
         /* Reconstruct cache contents, from image */
-        if(H5C__reconstruct_cache_contents(f, cache_ptr) < 0)
+        if (H5C__reconstruct_cache_contents(f, cache_ptr) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTDECODE, FAIL, "Can't reconstruct cache contents from image block")
 
         /* Free the image buffer */
@@ -1127,21 +1100,21 @@ H5C__load_cache_image(H5F_t *f)
     } /* end if */
 
     /* If directed, free the on disk metadata cache image */
-    if(cache_ptr->delete_image) {
-        if(H5F__super_ext_remove_msg(f, H5O_MDCI_MSG_ID) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, "can't remove metadata cache image message from superblock extension")
+    if (cache_ptr->delete_image) {
+        if (H5F__super_ext_remove_msg(f, H5O_MDCI_MSG_ID) < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL,
+                        "can't remove metadata cache image message from superblock extension")
 
         /* Reset image block values */
-        cache_ptr->image_len = 0;
+        cache_ptr->image_len      = 0;
         cache_ptr->image_data_len = 0;
-        cache_ptr->image_addr = HADDR_UNDEF;
+        cache_ptr->image_addr     = HADDR_UNDEF;
     } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__load_cache_image() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C_load_cache_image_on_next_protect()
  *
@@ -1171,8 +1144,7 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5C_load_cache_image_on_next_protect(H5F_t *f, haddr_t addr, hsize_t len,
-    hbool_t rw)
+H5C_load_cache_image_on_next_protect(H5F_t *f, haddr_t addr, hsize_t len, hbool_t rw)
 {
     H5C_t *cache_ptr;
 
@@ -1186,15 +1158,13 @@ H5C_load_cache_image_on_next_protect(H5F_t *f, haddr_t addr, hsize_t len,
     HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
 
     /* Set information needed to load cache image */
-    cache_ptr->image_addr   = addr,
-    cache_ptr->image_len    = len;
+    cache_ptr->image_addr = addr, cache_ptr->image_len = len;
     cache_ptr->load_image   = TRUE;
     cache_ptr->delete_image = rw;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5C_load_cache_image_on_next_protect() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__image_entry_cmp
  *
@@ -1220,9 +1190,11 @@ H5C_load_cache_image_on_next_protect(H5F_t *f, haddr_t addr, hsize_t len,
 static int
 H5C__image_entry_cmp(const void *_entry1, const void *_entry2)
 {
-    const H5C_image_entry_t *entry1 = (const H5C_image_entry_t *)_entry1;  /* Pointer to first image entry to compare */
-    const H5C_image_entry_t *entry2 = (const H5C_image_entry_t *)_entry2;  /* Pointer to second image entry to compare */
-    int ret_value = 0;          /* Return value */
+    const H5C_image_entry_t *entry1 =
+        (const H5C_image_entry_t *)_entry1; /* Pointer to first image entry to compare */
+    const H5C_image_entry_t *entry2 =
+        (const H5C_image_entry_t *)_entry2; /* Pointer to second image entry to compare */
+    int ret_value = 0;                      /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -1230,25 +1202,24 @@ H5C__image_entry_cmp(const void *_entry1, const void *_entry2)
     HDassert(entry1);
     HDassert(entry2);
 
-    if(entry1->image_fd_height > entry2->image_fd_height)
+    if (entry1->image_fd_height > entry2->image_fd_height)
         ret_value = -1;
-    else if(entry1->image_fd_height < entry2->image_fd_height)
+    else if (entry1->image_fd_height < entry2->image_fd_height)
         ret_value = 1;
     else {
         /* Sanity check */
         HDassert(entry1->lru_rank >= -1);
         HDassert(entry2->lru_rank >= -1);
 
-        if(entry1->lru_rank < entry2->lru_rank)
+        if (entry1->lru_rank < entry2->lru_rank)
             ret_value = -1;
-        else if(entry1->lru_rank > entry2->lru_rank)
+        else if (entry1->lru_rank > entry2->lru_rank)
             ret_value = 1;
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__image_entry_cmp() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__prep_image_for_file_close
  *
@@ -1299,10 +1270,10 @@ H5C__image_entry_cmp(const void *_entry1, const void *_entry2)
 herr_t
 H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
 {
-    H5C_t *     cache_ptr = NULL;
-    haddr_t     eoa_frag_addr = HADDR_UNDEF;
-    hsize_t     eoa_frag_size = 0;
-    herr_t	ret_value = SUCCEED;      /* Return value */
+    H5C_t * cache_ptr     = NULL;
+    haddr_t eoa_frag_addr = HADDR_UNDEF;
+    hsize_t eoa_frag_size = 0;
+    herr_t  ret_value     = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -1319,10 +1290,10 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
      * any group or data set, it is possible that the cache image (if
      * it exists) has not been read yet.  Do this now if required.
      */
-    if(cache_ptr->load_image) {
+    if (cache_ptr->load_image) {
         cache_ptr->load_image = FALSE;
-        if(H5C__load_cache_image(f) < 0)
-	    HGOTO_ERROR(H5E_CACHE, H5E_CANTLOAD, FAIL, "can't load cache image")
+        if (H5C__load_cache_image(f) < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTLOAD, FAIL, "can't load cache image")
     } /* end if */
 
     /* Before we start to generate the cache image (if requested), verify
@@ -1339,9 +1310,8 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
      * Also verify that the file's high_bound is at least release
      * 1.10.x, otherwise cancel the request for a cache image
      */
-    if((NULL == f->shared->sblock) ||
-         (f->shared->sblock->super_vers < HDF5_SUPERBLOCK_VERSION_2) ||
-         (f->shared->high_bound < H5F_LIBVER_V110)) {
+    if ((NULL == f->shared->sblock) || (f->shared->sblock->super_vers < HDF5_SUPERBLOCK_VERSION_2) ||
+        (f->shared->high_bound < H5F_LIBVER_V110)) {
         H5C_cache_image_ctl_t default_image_ctl = H5C__DEFAULT_CACHE_IMAGE_CTL;
 
         cache_ptr->image_ctl = default_image_ctl;
@@ -1349,7 +1319,7 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
     } /* end if */
 
     /* Generate the cache image, if requested */
-    if(cache_ptr->image_ctl.generate_image) {
+    if (cache_ptr->image_ctl.generate_image) {
         /* Create the cache image super block extension message.
          *
          * Note that the base address and length of the metadata cache
@@ -1364,12 +1334,12 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
          * H5C_CI__GEN_MDCI_SBE_MESG bit is set in
          * cache_ptr->image_ctl.flags.
          */
-        if(cache_ptr->image_ctl.flags & H5C_CI__GEN_MDCI_SBE_MESG)
-            if(H5C__write_cache_image_superblock_msg(f, TRUE) < 0)
+        if (cache_ptr->image_ctl.flags & H5C_CI__GEN_MDCI_SBE_MESG)
+            if (H5C__write_cache_image_superblock_msg(f, TRUE) < 0)
                 HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "creation of cache image SB mesg failed.")
 
         /* Serialize the cache */
-        if(H5C__serialize_cache(f) < 0)
+        if (H5C__serialize_cache(f) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "serialization of the cache failed")
 
         /* Scan the cache and record data needed to construct the
@@ -1388,7 +1358,7 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
          * image.  With the recent modifications of the free space
          * manager code, this size should be correct.
          */
-        if(H5C__prep_for_file_close__scan_entries(f, cache_ptr) < 0)
+        if (H5C__prep_for_file_close__scan_entries(f, cache_ptr) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C__prep_for_file_close__scan_entries failed")
         HDassert(HADDR_UNDEF == cache_ptr->image_addr);
 
@@ -1396,23 +1366,25 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
         /* In the parallel case, overwrite the image_len with the
          * value computed by process 0.
          */
-        if(cache_ptr->aux_ptr) { /* we have multiple processes */
-            int mpi_result;
-            unsigned p0_image_len;
-            H5AC_aux_t * aux_ptr;
+        if (cache_ptr->aux_ptr) { /* we have multiple processes */
+            int         mpi_result;
+            unsigned    p0_image_len;
+            H5AC_aux_t *aux_ptr;
 
             aux_ptr = (H5AC_aux_t *)cache_ptr->aux_ptr;
-            if(aux_ptr->mpi_rank == 0) {
+            if (aux_ptr->mpi_rank == 0) {
                 aux_ptr->p0_image_len = (unsigned)cache_ptr->image_data_len;
-                p0_image_len = aux_ptr->p0_image_len;
+                p0_image_len          = aux_ptr->p0_image_len;
 
-                if(MPI_SUCCESS != (mpi_result = MPI_Bcast(&p0_image_len, 1, MPI_UNSIGNED, 0, aux_ptr->mpi_comm)))
+                if (MPI_SUCCESS !=
+                    (mpi_result = MPI_Bcast(&p0_image_len, 1, MPI_UNSIGNED, 0, aux_ptr->mpi_comm)))
                     HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", mpi_result)
 
                 HDassert(p0_image_len == aux_ptr->p0_image_len);
             } /* end if */
             else {
-                if(MPI_SUCCESS != (mpi_result = MPI_Bcast(&p0_image_len, 1, MPI_UNSIGNED, 0, aux_ptr->mpi_comm)))
+                if (MPI_SUCCESS !=
+                    (mpi_result = MPI_Bcast(&p0_image_len, 1, MPI_UNSIGNED, 0, aux_ptr->mpi_comm)))
                     HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", mpi_result)
 
                 aux_ptr->p0_image_len = p0_image_len;
@@ -1427,9 +1399,11 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
              * Note that we allocate the cache image directly from the file
              * driver so as to avoid unsettling the free space managers.
              */
-            if(HADDR_UNDEF == (cache_ptr->image_addr = H5FD_alloc(f->shared->lf, H5FD_MEM_SUPER, f,
-                        (hsize_t)p0_image_len, &eoa_frag_addr, &eoa_frag_size)))
-                HGOTO_ERROR(H5E_CACHE, H5E_NOSPACE, FAIL, "can't allocate file space for metadata cache image")
+            if (HADDR_UNDEF ==
+                (cache_ptr->image_addr = H5FD_alloc(f->shared->lf, H5FD_MEM_SUPER, f, (hsize_t)p0_image_len,
+                                                    &eoa_frag_addr, &eoa_frag_size)))
+                HGOTO_ERROR(H5E_CACHE, H5E_NOSPACE, FAIL,
+                            "can't allocate file space for metadata cache image")
         } /* end if */
         else
 #endif /* H5_HAVE_PARALLEL */
@@ -1437,9 +1411,10 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
              * this space directly from the file driver so as to avoid
              * unsettling the free space managers.
              */
-            if(HADDR_UNDEF == (cache_ptr->image_addr = H5FD_alloc(f->shared->lf, H5FD_MEM_SUPER, f,
-                        (hsize_t)(cache_ptr->image_data_len), &eoa_frag_addr, &eoa_frag_size)))
-                HGOTO_ERROR(H5E_CACHE, H5E_NOSPACE, FAIL, "can't allocate file space for metadata cache image")
+            if (HADDR_UNDEF == (cache_ptr->image_addr = H5FD_alloc(f->shared->lf, H5FD_MEM_SUPER, f,
+                                                                   (hsize_t)(cache_ptr->image_data_len),
+                                                                   &eoa_frag_addr, &eoa_frag_size)))
+            HGOTO_ERROR(H5E_CACHE, H5E_NOSPACE, FAIL, "can't allocate file space for metadata cache image")
 
         /* Make note of the eoa after allocation of the cache image
          * block.  This value is used for sanity checking when we
@@ -1447,7 +1422,7 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
          * we destroy the metadata cache.
          */
         HDassert(HADDR_UNDEF == f->shared->eoa_post_mdci_fsalloc);
-        if(HADDR_UNDEF == (f->shared->eoa_post_mdci_fsalloc = H5FD_get_eoa(f->shared->lf, H5FD_MEM_DEFAULT)) )
+        if (HADDR_UNDEF == (f->shared->eoa_post_mdci_fsalloc = H5FD_get_eoa(f->shared->lf, H5FD_MEM_DEFAULT)))
             HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "unable to get file size")
 
         /* For now, drop any fragment left over from the allocation of the
@@ -1479,8 +1454,8 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
          * H5C_CI__GEN_MDC_IMAGE_BLK bit is set in
          * cache_ptr->image_ctl.flags.
          */
-        if(cache_ptr->image_ctl.flags & H5C_CI__GEN_MDC_IMAGE_BLK)
-            if(H5C__write_cache_image_superblock_msg(f, FALSE) < 0)
+        if (cache_ptr->image_ctl.flags & H5C_CI__GEN_MDC_IMAGE_BLK)
+            if (H5C__write_cache_image_superblock_msg(f, FALSE) < 0)
                 HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "update of cache image SB mesg failed")
 
         /* At this point:
@@ -1517,14 +1492,14 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
          * allow the file close to continue normally without the
          * unnecessary generation of the metadata cache image.
          */
-        if(cache_ptr->num_entries_in_image > 0) {
-            if(H5C__prep_for_file_close__setup_image_entries_array(cache_ptr) < 0)
+        if (cache_ptr->num_entries_in_image > 0) {
+            if (H5C__prep_for_file_close__setup_image_entries_array(cache_ptr) < 0)
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTINIT, FAIL, "can't setup image entries array.")
 
             /* Sort the entries */
             HDqsort(cache_ptr->image_entries, (size_t)cache_ptr->num_entries_in_image,
                     sizeof(H5C_image_entry_t), H5C__image_entry_cmp);
-        } /* end if */
+        }      /* end if */
         else { /* cancel creation of metadata cache image */
             HDassert(cache_ptr->image_entries == NULL);
 
@@ -1533,9 +1508,10 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated)
              * H5C_CI__GEN_MDC_IMAGE_BLK flag is set in
              * cache_ptr->image_ctl.flags.
              */
-            if(cache_ptr->image_ctl.flags & H5C_CI__GEN_MDC_IMAGE_BLK)
-                if(H5F__super_ext_remove_msg(f, H5O_MDCI_MSG_ID) < 0)
-                    HGOTO_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, "can't remove MDC image msg from superblock ext")
+            if (cache_ptr->image_ctl.flags & H5C_CI__GEN_MDC_IMAGE_BLK)
+                if (H5F__super_ext_remove_msg(f, H5O_MDCI_MSG_ID) < 0)
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL,
+                                "can't remove MDC image msg from superblock ext")
 
             cache_ptr->image_ctl.generate_image = FALSE;
         } /* end else */
@@ -1548,7 +1524,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__prep_image_for_file_close() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C_set_cache_image_config
  *
@@ -1578,10 +1553,9 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr,
-    H5C_cache_image_ctl_t *config_ptr)
+H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr, H5C_cache_image_ctl_t *config_ptr)
 {
-    herr_t	ret_value = SUCCEED;      /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -1591,11 +1565,11 @@ H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr,
     HDassert(f->shared->cache == f->shared->cache);
 
     /* Check arguments */
-    if((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC))
+    if ((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC))
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad cache_ptr on entry")
 
     /* Validate the config: */
-    if(H5C_validate_cache_image_config(config_ptr) < 0)
+    if (H5C_validate_cache_image_config(config_ptr) < 0)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid cache image configuration")
 
 #ifdef H5_HAVE_PARALLEL
@@ -1604,11 +1578,11 @@ H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr,
      * if there is more than one process.
      *                                         JRM -- 11/8/16
      */
-    if(cache_ptr->aux_ptr) {
-	H5C_cache_image_ctl_t default_image_ctl = H5C__DEFAULT_CACHE_IMAGE_CTL;
+    if (cache_ptr->aux_ptr) {
+        H5C_cache_image_ctl_t default_image_ctl = H5C__DEFAULT_CACHE_IMAGE_CTL;
 
         cache_ptr->image_ctl = default_image_ctl;
-	HDassert(!(cache_ptr->image_ctl.generate_image));
+        HDassert(!(cache_ptr->image_ctl.generate_image));
     } /* end if */
     else {
 #endif /* H5_HAVE_PARALLEL */
@@ -1624,7 +1598,7 @@ H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr,
          * If it is not, set the image configuration to the default, which has
          * the effect of silently disabling the cache image if it was requested.
          */
-        if(H5F_INTENT(f) & H5F_ACC_RDWR)
+        if (H5F_INTENT(f) & H5F_ACC_RDWR)
             cache_ptr->image_ctl = *config_ptr;
         else {
             H5C_cache_image_ctl_t default_image_ctl = H5C__DEFAULT_CACHE_IMAGE_CTL;
@@ -1633,14 +1607,13 @@ H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr,
             HDassert(!(cache_ptr->image_ctl.generate_image));
         } /* end else */
 #ifdef H5_HAVE_PARALLEL
-    } /* end else */
+    }  /* end else */
 #endif /* H5_HAVE_PARALLEL */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C_set_cache_image_config() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C_validate_cache_image_config()
  *
@@ -1658,39 +1631,38 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5C_validate_cache_image_config(H5C_cache_image_ctl_t * ctl_ptr)
+H5C_validate_cache_image_config(H5C_cache_image_ctl_t *ctl_ptr)
 {
-    herr_t              ret_value = SUCCEED;    /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    if(ctl_ptr == NULL)
+    if (ctl_ptr == NULL)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "NULL ctl_ptr on entry")
-    if(ctl_ptr->version != H5C__CURR_CACHE_IMAGE_CTL_VER)
+    if (ctl_ptr->version != H5C__CURR_CACHE_IMAGE_CTL_VER)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown cache image control version")
 
     /* At present, we do not support inclusion of the adaptive resize
      * configuration in the cache image.  Thus the save_resize_status
      * field must be FALSE.
      */
-    if(ctl_ptr->save_resize_status != FALSE)
+    if (ctl_ptr->save_resize_status != FALSE)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "unexpected value in save_resize_status field")
 
     /* At present, we do not support prefetched entry ageouts.  Thus
      * the entry_ageout field must be set to
      * H5AC__CACHE_IMAGE__ENTRY_AGEOUT__NONE.
      */
-    if(ctl_ptr->entry_ageout != H5AC__CACHE_IMAGE__ENTRY_AGEOUT__NONE)
+    if (ctl_ptr->entry_ageout != H5AC__CACHE_IMAGE__ENTRY_AGEOUT__NONE)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "unexpected value in entry_ageout field")
 
-    if((ctl_ptr->flags & ~H5C_CI__ALL_FLAGS) != 0)
+    if ((ctl_ptr->flags & ~H5C_CI__ALL_FLAGS) != 0)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "unknown flag set")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C_validate_cache_image_config() */
 
-
 /*************************************************************************/
 /**************************** Private Functions: *************************/
 /*************************************************************************/
@@ -1710,28 +1682,27 @@ done:
  *-------------------------------------------------------------------------
  */
 static size_t
-H5C__cache_image_block_entry_header_size(const H5F_t * f)
+H5C__cache_image_block_entry_header_size(const H5F_t *f)
 {
-    size_t ret_value = 0;       /* Return value */
+    size_t ret_value = 0; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
     /* Set return value */
-    ret_value = (size_t)( 1 +			/* type                     */
-			  1 +			/* flags                    */
-			  1 +			/* ring                     */
-			  1 +			/* age                      */
-			  2 +			/* dependency child count   */
-			  2 +			/* dirty dep child count    */
-			  2 +			/* dependency parent count  */
-			  4 +			/* index in LRU             */
-			  H5F_SIZEOF_ADDR(f) +  /* entry offset             */
-			  H5F_SIZEOF_SIZE(f) ); /* entry length             */
+    ret_value = (size_t)(1 +                  /* type                     */
+                         1 +                  /* flags                    */
+                         1 +                  /* ring                     */
+                         1 +                  /* age                      */
+                         2 +                  /* dependency child count   */
+                         2 +                  /* dirty dep child count    */
+                         2 +                  /* dependency parent count  */
+                         4 +                  /* index in LRU             */
+                         H5F_SIZEOF_ADDR(f) + /* entry offset             */
+                         H5F_SIZEOF_SIZE(f)); /* entry length             */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__cache_image_block_entry_header_size() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__cache_image_block_header_size
  *
@@ -1747,23 +1718,22 @@ H5C__cache_image_block_entry_header_size(const H5F_t * f)
  *-------------------------------------------------------------------------
  */
 static size_t
-H5C__cache_image_block_header_size(const H5F_t * f)
+H5C__cache_image_block_header_size(const H5F_t *f)
 {
-    size_t ret_value = 0;       /* Return value */
+    size_t ret_value = 0; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
     /* Set return value */
-    ret_value = (size_t)( 4 +                   /* signature           */
-			  1 +			/* version             */
-			  1 +			/* flags               */
-			  H5F_SIZEOF_SIZE(f) +	/* image data length   */
-			  4 );			/* num_entries         */
+    ret_value = (size_t)(4 +                  /* signature           */
+                         1 +                  /* version             */
+                         1 +                  /* flags               */
+                         H5F_SIZEOF_SIZE(f) + /* image data length   */
+                         4);                  /* num_entries         */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__cache_image_block_header_size() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__decode_cache_image_header()
  *
@@ -1780,16 +1750,15 @@ H5C__cache_image_block_header_size(const H5F_t * f)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5C__decode_cache_image_header(const H5F_t *f, H5C_t *cache_ptr,
-    const uint8_t **buf)
+H5C__decode_cache_image_header(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **buf)
 {
-    uint8_t		version;
-    uint8_t		flags;
-    hbool_t		have_resize_status = FALSE;
-    size_t 		actual_header_len;
-    size_t		expected_header_len;
-    const uint8_t *	p;
-    herr_t		ret_value = SUCCEED;      /* Return value */
+    uint8_t        version;
+    uint8_t        flags;
+    hbool_t        have_resize_status = FALSE;
+    size_t         actual_header_len;
+    size_t         expected_header_len;
+    const uint8_t *p;
+    herr_t         ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -1803,38 +1772,38 @@ H5C__decode_cache_image_header(const H5F_t *f, H5C_t *cache_ptr,
     p = *buf;
 
     /* Check signature */
-    if(HDmemcmp(p, H5C__MDCI_BLOCK_SIGNATURE, (size_t)H5C__MDCI_BLOCK_SIGNATURE_LEN))
-	HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad metadata cache image header signature")
+    if (HDmemcmp(p, H5C__MDCI_BLOCK_SIGNATURE, (size_t)H5C__MDCI_BLOCK_SIGNATURE_LEN))
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad metadata cache image header signature")
     p += H5C__MDCI_BLOCK_SIGNATURE_LEN;
 
     /* Check version */
     version = *p++;
-    if(version != (uint8_t)H5C__MDCI_BLOCK_VERSION_0)
-	HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad metadata cache image version")
+    if (version != (uint8_t)H5C__MDCI_BLOCK_VERSION_0)
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad metadata cache image version")
 
     /* Decode flags */
     flags = *p++;
-    if(flags & H5C__MDCI_HEADER_HAVE_RESIZE_STATUS)
-	have_resize_status = TRUE;
-    if(have_resize_status)
-	HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "MDC resize status not yet supported")
+    if (flags & H5C__MDCI_HEADER_HAVE_RESIZE_STATUS)
+        have_resize_status = TRUE;
+    if (have_resize_status)
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "MDC resize status not yet supported")
 
     /* Read image data length */
     H5F_DECODE_LENGTH(f, p, cache_ptr->image_data_len);
 
     /* For now -- will become <= eventually */
-    if(cache_ptr->image_data_len != cache_ptr->image_len)
-	HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad metadata cache image data length")
+    if (cache_ptr->image_data_len != cache_ptr->image_len)
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad metadata cache image data length")
 
     /* Read num entries */
     UINT32DECODE(p, cache_ptr->num_entries_in_image);
-    if(cache_ptr->num_entries_in_image == 0)
-	HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad metadata cache entry count")
+    if (cache_ptr->num_entries_in_image == 0)
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad metadata cache entry count")
 
     /* Verify expected length of header */
-    actual_header_len = (size_t)(p - *buf);
+    actual_header_len   = (size_t)(p - *buf);
     expected_header_len = H5C__cache_image_block_header_size(f);
-    if(actual_header_len != expected_header_len)
+    if (actual_header_len != expected_header_len)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad header image len")
 
     /* Update buffer pointer */
@@ -1845,7 +1814,7 @@ done:
 } /* H5C__decode_cache_image_header() */
 
 #ifndef NDEBUG
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5C__decode_cache_image_entry()
  *
@@ -1866,28 +1835,27 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr,
-    const uint8_t **buf, unsigned entry_num)
+H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr, const uint8_t **buf, unsigned entry_num)
 {
-    hbool_t		is_dirty = FALSE;
-    hbool_t		in_lru = FALSE;         /* Only used in assertions */
-    hbool_t		is_fd_parent = FALSE;   /* Only used in assertions */
-    hbool_t		is_fd_child = FALSE;    /* Only used in assertions */
-    haddr_t 		addr;
-    hsize_t		size = 0;
-    void *		image_ptr;
-    uint8_t             flags = 0;
-    uint8_t		type_id;
-    uint8_t		ring;
-    uint8_t		age;
-    uint16_t 		fd_child_count;
-    uint16_t 		fd_dirty_child_count;
-    uint16_t 		fd_parent_count;
-    haddr_t           * fd_parent_addrs = NULL;
-    int32_t		lru_rank;
-    H5C_image_entry_t * ie_ptr = NULL;
-    const uint8_t *	p;
-    herr_t		ret_value = SUCCEED;      /* Return value */
+    hbool_t            is_dirty     = FALSE;
+    hbool_t            in_lru       = FALSE; /* Only used in assertions */
+    hbool_t            is_fd_parent = FALSE; /* Only used in assertions */
+    hbool_t            is_fd_child  = FALSE; /* Only used in assertions */
+    haddr_t            addr;
+    hsize_t            size = 0;
+    void *             image_ptr;
+    uint8_t            flags = 0;
+    uint8_t            type_id;
+    uint8_t            ring;
+    uint8_t            age;
+    uint16_t           fd_child_count;
+    uint16_t           fd_dirty_child_count;
+    uint16_t           fd_parent_count;
+    haddr_t *          fd_parent_addrs = NULL;
+    int32_t            lru_rank;
+    H5C_image_entry_t *ie_ptr = NULL;
+    const uint8_t *    p;
+    herr_t             ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -1912,13 +1880,13 @@ H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr,
 
     /* Decode flags */
     flags = *p++;
-    if(flags & H5C__MDCI_ENTRY_DIRTY_FLAG)
+    if (flags & H5C__MDCI_ENTRY_DIRTY_FLAG)
         is_dirty = TRUE;
-    if(flags & H5C__MDCI_ENTRY_IN_LRU_FLAG)
+    if (flags & H5C__MDCI_ENTRY_IN_LRU_FLAG)
         in_lru = TRUE;
-    if(flags & H5C__MDCI_ENTRY_IS_FD_PARENT_FLAG)
+    if (flags & H5C__MDCI_ENTRY_IS_FD_PARENT_FLAG)
         is_fd_parent = TRUE;
-    if(flags & H5C__MDCI_ENTRY_IS_FD_CHILD_FLAG)
+    if (flags & H5C__MDCI_ENTRY_IS_FD_CHILD_FLAG)
         is_fd_child = TRUE;
 
     /* Decode ring */
@@ -1935,7 +1903,7 @@ H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr,
 
     /* Decode dirty dependency child count */
     UINT16DECODE(p, fd_dirty_child_count);
-    if(fd_dirty_child_count > fd_child_count)
+    if (fd_dirty_child_count > fd_child_count)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "invalid dirty flush dependency child count")
 
     /* Decode dependency parent count */
@@ -1948,37 +1916,37 @@ H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr,
 
     /* Decode entry offset */
     H5F_addr_decode(f, &p, &addr);
-    if(!H5F_addr_defined(addr))
+    if (!H5F_addr_defined(addr))
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "invalid entry offset")
 
     /* Decode entry length */
     H5F_DECODE_LENGTH(f, p, size);
-    if(size == 0)
+    if (size == 0)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "invalid entry size")
 
     /* Verify expected length of entry image */
-    if((size_t)(p - *buf) != H5C__cache_image_block_entry_header_size(f))
+    if ((size_t)(p - *buf) != H5C__cache_image_block_entry_header_size(f))
         HGOTO_ERROR(H5E_CACHE, H5E_BADSIZE, FAIL, "Bad entry image len")
 
     /* If parent count greater than zero, allocate array for parent
      * addresses, and decode addresses into the array.
      */
-    if(fd_parent_count > 0) {
-        int i;          /* Local index variable */
+    if (fd_parent_count > 0) {
+        int i; /* Local index variable */
 
-        if(NULL == (fd_parent_addrs = (haddr_t *)H5MM_malloc((size_t)(fd_parent_count) * H5F_SIZEOF_ADDR(f))))
-	    HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for fd parent addrs buffer")
+        if (NULL == (fd_parent_addrs = (haddr_t *)H5MM_malloc((size_t)(fd_parent_count)*H5F_SIZEOF_ADDR(f))))
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for fd parent addrs buffer")
 
-	for(i = 0; i < fd_parent_count; i++) {
+        for (i = 0; i < fd_parent_count; i++) {
             H5F_addr_decode(f, &p, &(fd_parent_addrs[i]));
-            if(!H5F_addr_defined(fd_parent_addrs[i]))
+            if (!H5F_addr_defined(fd_parent_addrs[i]))
                 HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "invalid flush dependency parent offset")
         } /* end for */
-    } /* end if */
+    }     /* end if */
 
     /* Allocate buffer for entry image */
-    if(NULL == (image_ptr = H5MM_malloc(size + H5C_IMAGE_EXTRA_SPACE)))
-	HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for on disk image buffer")
+    if (NULL == (image_ptr = H5MM_malloc(size + H5C_IMAGE_EXTRA_SPACE)))
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for on disk image buffer")
 
 #if H5C_DO_MEMORY_SANITY_CHECKS
     H5MM_memcpy(((uint8_t *)image_ptr) + size, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
@@ -2010,7 +1978,6 @@ done:
 } /* H5C__decode_cache_image_entry() */
 #endif /* NDEBUG */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__destroy_pf_entry_child_flush_deps()
  *
@@ -2037,14 +2004,14 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr,
-    H5C_cache_entry_t *pf_entry_ptr, H5C_cache_entry_t **fd_children)
+H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr, H5C_cache_entry_t *pf_entry_ptr,
+                                       H5C_cache_entry_t **fd_children)
 {
-    H5C_cache_entry_t * entry_ptr;
-    unsigned		entries_visited = 0;
-    int			fd_children_found = 0;
-    hbool_t		found;
-    herr_t		ret_value = SUCCEED;    /* Return value */
+    H5C_cache_entry_t *entry_ptr;
+    unsigned           entries_visited   = 0;
+    int                fd_children_found = 0;
+    hbool_t            found;
+    herr_t             ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -2061,68 +2028,69 @@ H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr,
 
     /* Scan each entry on the index list */
     entry_ptr = cache_ptr->il_head;
-    while(entry_ptr != NULL) {
-	HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+    while (entry_ptr != NULL) {
+        HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
-	/* Here we look at entry_ptr->flush_dep_nparents and not
+        /* Here we look at entry_ptr->flush_dep_nparents and not
          * entry_ptr->fd_parent_count as it is possible that some
-	 * or all of the prefetched flush dependency child relationships
-	 * have already been destroyed.
+         * or all of the prefetched flush dependency child relationships
+         * have already been destroyed.
          */
-	if(entry_ptr->prefetched && (entry_ptr->flush_dep_nparents > 0)) {
-            unsigned u;         /* Local index variable */
+        if (entry_ptr->prefetched && (entry_ptr->flush_dep_nparents > 0)) {
+            unsigned u; /* Local index variable */
 
             /* Re-init */
-	    u = 0;
-	    found = FALSE;
+            u     = 0;
+            found = FALSE;
 
             /* Sanity checks */
             HDassert(entry_ptr->type);
             HDassert(entry_ptr->type->id == H5AC_PREFETCHED_ENTRY_ID);
-	    HDassert(entry_ptr->fd_parent_count >= entry_ptr->flush_dep_nparents);
-	    HDassert(entry_ptr->fd_parent_addrs);
-	    HDassert(entry_ptr->flush_dep_parent);
+            HDassert(entry_ptr->fd_parent_count >= entry_ptr->flush_dep_nparents);
+            HDassert(entry_ptr->fd_parent_addrs);
+            HDassert(entry_ptr->flush_dep_parent);
 
             /* Look for correct entry */
-	    while(!found && (u < entry_ptr->fd_parent_count)) {
+            while (!found && (u < entry_ptr->fd_parent_count)) {
                 /* Sanity check entry */
-		HDassert(entry_ptr->flush_dep_parent[u]);
-		HDassert(entry_ptr->flush_dep_parent[u]->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                HDassert(entry_ptr->flush_dep_parent[u]);
+                HDassert(entry_ptr->flush_dep_parent[u]->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
                 /* Correct entry? */
-		if(pf_entry_ptr == entry_ptr->flush_dep_parent[u])
-		    found = TRUE;
+                if (pf_entry_ptr == entry_ptr->flush_dep_parent[u])
+                    found = TRUE;
 
-		u++;
+                u++;
             } /* end while */
 
-	    if(found) {
-	        HDassert(NULL == fd_children[fd_children_found]);
+            if (found) {
+                HDassert(NULL == fd_children[fd_children_found]);
 
                 /* Remove flush dependency */
-	        fd_children[fd_children_found] = entry_ptr;
-	        fd_children_found++;
-                if(H5C_destroy_flush_dependency(pf_entry_ptr, entry_ptr) < 0)
-	            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "can't destroy pf entry child flush dependency")
+                fd_children[fd_children_found] = entry_ptr;
+                fd_children_found++;
+                if (H5C_destroy_flush_dependency(pf_entry_ptr, entry_ptr) < 0)
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL,
+                                "can't destroy pf entry child flush dependency")
 
 #ifndef NDEBUG
-		/* Sanity check -- verify that the address of the parent
+                /* Sanity check -- verify that the address of the parent
                  * appears in entry_ptr->fd_parent_addrs.  Must do a search,
                  * as with flush dependency creates and destroys,
                  * entry_ptr->fd_parent_addrs and entry_ptr->flush_dep_parent
                  * can list parents in different order.
                  */
-		found = FALSE;
-		u = 0;
-	        while(!found && u < entry_ptr->fd_parent_count) {
-		    if(pf_entry_ptr->addr == entry_ptr->fd_parent_addrs[u])
-		        found = TRUE;
-		    u++;
+                found = FALSE;
+                u     = 0;
+                while (!found && u < entry_ptr->fd_parent_count) {
+                    if (pf_entry_ptr->addr == entry_ptr->fd_parent_addrs[u])
+                        found = TRUE;
+                    u++;
                 } /* end while */
-		HDassert(found);
-#endif /* NDEBUG */
-	    } /* end if */
-	} /* end if */
+                HDassert(found);
+#endif        /* NDEBUG */
+            } /* end if */
+        }     /* end if */
 
         entries_visited++;
         entry_ptr = entry_ptr->il_next;
@@ -2138,7 +2106,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__destroy_pf_entry_child_flush_deps() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__encode_cache_image_header()
  *
@@ -2154,14 +2121,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5C__encode_cache_image_header(const H5F_t *f, const H5C_t *cache_ptr,
-    uint8_t **buf)
+H5C__encode_cache_image_header(const H5F_t *f, const H5C_t *cache_ptr, uint8_t **buf)
 {
-    size_t 	actual_header_len;
-    size_t	expected_header_len;
-    uint8_t     flags = 0;
-    uint8_t *	p;                      /* Pointer into cache image buffer */
-    herr_t	ret_value = SUCCEED;    /* Return value */
+    size_t   actual_header_len;
+    size_t   expected_header_len;
+    uint8_t  flags = 0;
+    uint8_t *p;                   /* Pointer into cache image buffer */
+    herr_t   ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -2190,8 +2156,8 @@ H5C__encode_cache_image_header(const H5F_t *f, const H5C_t *cache_ptr,
 
     /* at present we don't support saving resize status */
     HDassert(!cache_ptr->image_ctl.save_resize_status);
-    if(cache_ptr->image_ctl.save_resize_status)
-	flags |= H5C__MDCI_HEADER_HAVE_RESIZE_STATUS;
+    if (cache_ptr->image_ctl.save_resize_status)
+        flags |= H5C__MDCI_HEADER_HAVE_RESIZE_STATUS;
 
     *p++ = flags;
 
@@ -2204,9 +2170,9 @@ H5C__encode_cache_image_header(const H5F_t *f, const H5C_t *cache_ptr,
     UINT32ENCODE(p, cache_ptr->num_entries_in_image);
 
     /* verify expected length of header */
-    actual_header_len = (size_t)(p - *buf);
+    actual_header_len   = (size_t)(p - *buf);
     expected_header_len = H5C__cache_image_block_header_size(f);
-    if(actual_header_len != expected_header_len)
+    if (actual_header_len != expected_header_len)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad header image len")
 
     /* Update buffer pointer */
@@ -2216,7 +2182,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__encode_cache_image_header() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__encode_cache_image_entry()
  *
@@ -2232,14 +2197,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf,
-    unsigned entry_num)
+H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf, unsigned entry_num)
 {
-    H5C_image_entry_t *	ie_ptr;                 /* Pointer to entry to encode */
-    uint8_t             flags = 0;              /* Flags for entry */
-    uint8_t           *	p;                      /* Pointer into cache image buffer */
-    unsigned            u;                      /* Local index value */
-    herr_t		ret_value = SUCCEED;    /* Return value */
+    H5C_image_entry_t *ie_ptr;              /* Pointer to entry to encode */
+    uint8_t            flags = 0;           /* Flags for entry */
+    uint8_t *          p;                   /* Pointer into cache image buffer */
+    unsigned           u;                   /* Local index value */
+    herr_t             ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -2262,19 +2226,19 @@ H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf,
     p = *buf;
 
     /* Encode type */
-    if((ie_ptr->type_id < 0) || (ie_ptr->type_id > 255))
+    if ((ie_ptr->type_id < 0) || (ie_ptr->type_id > 255))
         HGOTO_ERROR(H5E_CACHE, H5E_BADRANGE, FAIL, "type_id out of range.")
     *p++ = (uint8_t)(ie_ptr->type_id);
 
     /* Compose and encode flags */
-    if(ie_ptr->is_dirty)
-	flags |= H5C__MDCI_ENTRY_DIRTY_FLAG;
-    if(ie_ptr->lru_rank > 0)
-	flags |= H5C__MDCI_ENTRY_IN_LRU_FLAG;
-    if(ie_ptr->fd_child_count > 0)
-	flags |= H5C__MDCI_ENTRY_IS_FD_PARENT_FLAG;
-    if(ie_ptr->fd_parent_count > 0)
-	flags |= H5C__MDCI_ENTRY_IS_FD_CHILD_FLAG;
+    if (ie_ptr->is_dirty)
+        flags |= H5C__MDCI_ENTRY_DIRTY_FLAG;
+    if (ie_ptr->lru_rank > 0)
+        flags |= H5C__MDCI_ENTRY_IN_LRU_FLAG;
+    if (ie_ptr->fd_child_count > 0)
+        flags |= H5C__MDCI_ENTRY_IS_FD_PARENT_FLAG;
+    if (ie_ptr->fd_parent_count > 0)
+        flags |= H5C__MDCI_ENTRY_IS_FD_CHILD_FLAG;
     *p++ = flags;
 
     /* Encode ring */
@@ -2284,17 +2248,17 @@ H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf,
     *p++ = (uint8_t)(ie_ptr->age);
 
     /* Validate and encode dependency child count */
-    if(ie_ptr->fd_child_count > H5C__MDCI_MAX_FD_CHILDREN)
+    if (ie_ptr->fd_child_count > H5C__MDCI_MAX_FD_CHILDREN)
         HGOTO_ERROR(H5E_CACHE, H5E_BADRANGE, FAIL, "fd_child_count out of range")
     UINT16ENCODE(p, (uint16_t)(ie_ptr->fd_child_count));
 
     /* Validate and encode dirty dependency child count */
-    if(ie_ptr->fd_dirty_child_count > H5C__MDCI_MAX_FD_CHILDREN)
+    if (ie_ptr->fd_dirty_child_count > H5C__MDCI_MAX_FD_CHILDREN)
         HGOTO_ERROR(H5E_CACHE, H5E_BADRANGE, FAIL, "fd_dirty_child_count out of range")
     UINT16ENCODE(p, (uint16_t)(ie_ptr->fd_dirty_child_count));
 
     /* Validate and encode dependency parent count */
-    if(ie_ptr->fd_parent_count > H5C__MDCI_MAX_FD_PARENTS)
+    if (ie_ptr->fd_parent_count > H5C__MDCI_MAX_FD_PARENTS)
         HGOTO_ERROR(H5E_CACHE, H5E_BADRANGE, FAIL, "fd_parent_count out of range")
     UINT16ENCODE(p, (uint16_t)(ie_ptr->fd_parent_count));
 
@@ -2308,12 +2272,12 @@ H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf,
     H5F_ENCODE_LENGTH(f, p, ie_ptr->size);
 
     /* Verify expected length of entry image */
-    if((size_t)(p - *buf) != H5C__cache_image_block_entry_header_size(f))
+    if ((size_t)(p - *buf) != H5C__cache_image_block_entry_header_size(f))
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad entry image len")
 
     /* Encode dependency parent offsets -- if any */
-    for(u = 0; u < ie_ptr->fd_parent_count; u++)
-	H5F_addr_encode(f, &p, ie_ptr->fd_parent_addrs[u]);
+    for (u = 0; u < ie_ptr->fd_parent_count; u++)
+        H5F_addr_encode(f, &p, ie_ptr->fd_parent_addrs[u]);
 
     /* Copy entry image */
     H5MM_memcpy(p, ie_ptr->image_ptr, ie_ptr->size);
@@ -2326,7 +2290,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__encode_cache_image_entry() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__prep_for_file_close__compute_fd_heights
  *
@@ -2393,14 +2356,14 @@ done:
 static herr_t
 H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr)
 {
-    H5C_cache_entry_t * entry_ptr;
-    H5C_cache_entry_t * parent_ptr;
-    unsigned		entries_removed_from_image = 0;
-    unsigned		external_parent_fd_refs_removed = 0;
-    unsigned		external_child_fd_refs_removed = 0;
-    hbool_t 		done = FALSE;
-    unsigned		u;              /* Local index variable */
-    herr_t              ret_value = SUCCEED;
+    H5C_cache_entry_t *entry_ptr;
+    H5C_cache_entry_t *parent_ptr;
+    unsigned           entries_removed_from_image      = 0;
+    unsigned           external_parent_fd_refs_removed = 0;
+    unsigned           external_child_fd_refs_removed  = 0;
+    hbool_t            done                            = FALSE;
+    unsigned           u; /* Local index variable */
+    herr_t             ret_value = SUCCEED;
 
     FUNC_ENTER_STATIC
 
@@ -2416,36 +2379,35 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr)
      * multiple passes through the index list.
      */
     done = FALSE;
-    while(!done) {
-	done = TRUE;
-	entry_ptr = cache_ptr->il_head;
-        while(entry_ptr != NULL) {
-	    HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+    while (!done) {
+        done      = TRUE;
+        entry_ptr = cache_ptr->il_head;
+        while (entry_ptr != NULL) {
+            HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
             /* Should this entry be in the image */
-	    if(entry_ptr->image_dirty && entry_ptr->include_in_image &&
-                    (entry_ptr->fd_parent_count > 0)) {
-		HDassert(entry_ptr->flush_dep_parent != NULL);
-		for(u = 0; u < entry_ptr->flush_dep_nparents; u++ ) {
-		    parent_ptr = entry_ptr->flush_dep_parent[u];
+            if (entry_ptr->image_dirty && entry_ptr->include_in_image && (entry_ptr->fd_parent_count > 0)) {
+                HDassert(entry_ptr->flush_dep_parent != NULL);
+                for (u = 0; u < entry_ptr->flush_dep_nparents; u++) {
+                    parent_ptr = entry_ptr->flush_dep_parent[u];
 
                     /* Sanity check parent */
-		    HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-		    HDassert(entry_ptr->ring == parent_ptr->ring);
+                    HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                    HDassert(entry_ptr->ring == parent_ptr->ring);
 
-		    if(parent_ptr->is_dirty && !parent_ptr->include_in_image &&
-                             entry_ptr->include_in_image) {
+                    if (parent_ptr->is_dirty && !parent_ptr->include_in_image &&
+                        entry_ptr->include_in_image) {
 
-			/* Must remove child from image -- only do this once */
-			entries_removed_from_image++;
-			entry_ptr->include_in_image = FALSE;
-		    } /* end if */
-		} /* for */
-            } /* end if */
+                        /* Must remove child from image -- only do this once */
+                        entries_removed_from_image++;
+                        entry_ptr->include_in_image = FALSE;
+                    } /* end if */
+                }     /* for */
+            }         /* end if */
 
-	    entry_ptr = entry_ptr->il_next;
+            entry_ptr = entry_ptr->il_next;
         } /* while ( entry_ptr != NULL ) */
-    } /* while ( ! done ) */
+    }     /* while ( ! done ) */
 
     /* at present, entries are included in the cache image if they reside
      * in a specified set of rings.  Thus it should be impossible for
@@ -2459,79 +2421,81 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr)
      * flush dependency parents or children that are not in the cache image.
      */
     entry_ptr = cache_ptr->il_head;
-    while(entry_ptr != NULL) {
-	if(!entry_ptr->include_in_image && entry_ptr->flush_dep_nparents > 0) {
-	    HDassert(entry_ptr->flush_dep_parent != NULL);
+    while (entry_ptr != NULL) {
+        if (!entry_ptr->include_in_image && entry_ptr->flush_dep_nparents > 0) {
+            HDassert(entry_ptr->flush_dep_parent != NULL);
 
-	    for(u = 0; u < entry_ptr->flush_dep_nparents; u++ ) {
-	        parent_ptr = entry_ptr->flush_dep_parent[u];
+            for (u = 0; u < entry_ptr->flush_dep_nparents; u++) {
+                parent_ptr = entry_ptr->flush_dep_parent[u];
 
                 /* Sanity check parent */
-		HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-		HDassert(entry_ptr->ring == parent_ptr->ring);
-
-		if(parent_ptr->include_in_image) {
-		    /* Must remove reference to child */
-		    HDassert(parent_ptr->fd_child_count > 0);
-		    parent_ptr->fd_child_count--;
-
-		    if(entry_ptr->is_dirty) {
-			HDassert(parent_ptr->fd_dirty_child_count > 0);
-			parent_ptr->fd_dirty_child_count--;
-		    } /* end if */
-
-		    external_child_fd_refs_removed++;
-		} /* end if */
-	    } /* for */
-	} /* end if */
-        else if(entry_ptr->include_in_image && entry_ptr->flush_dep_nparents > 0) {
+                HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                HDassert(entry_ptr->ring == parent_ptr->ring);
+
+                if (parent_ptr->include_in_image) {
+                    /* Must remove reference to child */
+                    HDassert(parent_ptr->fd_child_count > 0);
+                    parent_ptr->fd_child_count--;
+
+                    if (entry_ptr->is_dirty) {
+                        HDassert(parent_ptr->fd_dirty_child_count > 0);
+                        parent_ptr->fd_dirty_child_count--;
+                    } /* end if */
+
+                    external_child_fd_refs_removed++;
+                } /* end if */
+            }     /* for */
+        }         /* end if */
+        else if (entry_ptr->include_in_image && entry_ptr->flush_dep_nparents > 0) {
             /* Sanity checks */
-	    HDassert(entry_ptr->flush_dep_parent != NULL);
-	    HDassert(entry_ptr->flush_dep_nparents == entry_ptr->fd_parent_count);
-	    HDassert(entry_ptr->fd_parent_addrs);
+            HDassert(entry_ptr->flush_dep_parent != NULL);
+            HDassert(entry_ptr->flush_dep_nparents == entry_ptr->fd_parent_count);
+            HDassert(entry_ptr->fd_parent_addrs);
 
-	    for(u = 0; u < entry_ptr->flush_dep_nparents; u++ ) {
-	        parent_ptr = entry_ptr->flush_dep_parent[u];
+            for (u = 0; u < entry_ptr->flush_dep_nparents; u++) {
+                parent_ptr = entry_ptr->flush_dep_parent[u];
 
                 /* Sanity check parent */
-		HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-		HDassert(entry_ptr->ring == parent_ptr->ring);
-
-		if(!parent_ptr->include_in_image) {
-		    /* Must remove reference to parent */
-		    HDassert(entry_ptr->fd_parent_count > 0);
-		    parent_ptr->fd_child_count--;
-
-		    HDassert(parent_ptr->addr == entry_ptr->fd_parent_addrs[u]);
-
-		    entry_ptr->fd_parent_addrs[u] = HADDR_UNDEF;
-		    external_parent_fd_refs_removed++;
-		} /* end if */
-	    } /* for */
-
-	    /* Touch up fd_parent_addrs array if necessary */
-	    if(entry_ptr->fd_parent_count == 0) {
-		H5MM_xfree(entry_ptr->fd_parent_addrs);
-		entry_ptr->fd_parent_addrs = NULL;
-	    } /* end if */
-            else if(entry_ptr->flush_dep_nparents > entry_ptr->fd_parent_count) {
-		haddr_t * old_fd_parent_addrs = entry_ptr->fd_parent_addrs;
+                HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                HDassert(entry_ptr->ring == parent_ptr->ring);
+
+                if (!parent_ptr->include_in_image) {
+                    /* Must remove reference to parent */
+                    HDassert(entry_ptr->fd_parent_count > 0);
+                    parent_ptr->fd_child_count--;
+
+                    HDassert(parent_ptr->addr == entry_ptr->fd_parent_addrs[u]);
+
+                    entry_ptr->fd_parent_addrs[u] = HADDR_UNDEF;
+                    external_parent_fd_refs_removed++;
+                } /* end if */
+            }     /* for */
+
+            /* Touch up fd_parent_addrs array if necessary */
+            if (entry_ptr->fd_parent_count == 0) {
+                H5MM_xfree(entry_ptr->fd_parent_addrs);
+                entry_ptr->fd_parent_addrs = NULL;
+            } /* end if */
+            else if (entry_ptr->flush_dep_nparents > entry_ptr->fd_parent_count) {
+                haddr_t *old_fd_parent_addrs = entry_ptr->fd_parent_addrs;
                 unsigned v;
 
-		if(NULL == (entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_calloc(sizeof(haddr_t) * (size_t)(entry_ptr->fd_parent_addrs))))
-		    HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for fd parent addr array")
+                if (NULL == (entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_calloc(
+                                 sizeof(haddr_t) * (size_t)(entry_ptr->fd_parent_addrs))))
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL,
+                                "memory allocation failed for fd parent addr array")
 
-		v = 0;
-	        for(u = 0; u < entry_ptr->flush_dep_nparents; u++) {
-		    if(old_fd_parent_addrs[u] != HADDR_UNDEF) {
-			entry_ptr->fd_parent_addrs[v] = old_fd_parent_addrs[u];
-			v++;
-		    } /* end if */
-		} /* end for */
+                v = 0;
+                for (u = 0; u < entry_ptr->flush_dep_nparents; u++) {
+                    if (old_fd_parent_addrs[u] != HADDR_UNDEF) {
+                        entry_ptr->fd_parent_addrs[v] = old_fd_parent_addrs[u];
+                        v++;
+                    } /* end if */
+                }     /* end for */
 
-		HDassert(v == entry_ptr->fd_parent_count);
-	    } /* end else-if */
-	} /* end else-if */
+                HDassert(v == entry_ptr->fd_parent_count);
+            } /* end else-if */
+        }     /* end else-if */
 
         entry_ptr = entry_ptr->il_next;
     } /* while (entry_ptr != NULL) */
@@ -2554,17 +2518,16 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr)
      * for all entries that may appear in the cache image.
      */
     entry_ptr = cache_ptr->il_head;
-    while(entry_ptr != NULL) {
-	if(entry_ptr->include_in_image && entry_ptr->fd_child_count == 0 &&
-                entry_ptr->fd_parent_count > 0) {
-	    for(u = 0; u < entry_ptr->fd_parent_count; u++) {
-	        parent_ptr = entry_ptr->flush_dep_parent[u];
-
-	        HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-	        if(parent_ptr->include_in_image && parent_ptr->image_fd_height <= 0)
-		    H5C__prep_for_file_close__compute_fd_heights_real(parent_ptr, 1);
-	    } /* end for */
-        } /* end if */
+    while (entry_ptr != NULL) {
+        if (entry_ptr->include_in_image && entry_ptr->fd_child_count == 0 && entry_ptr->fd_parent_count > 0) {
+            for (u = 0; u < entry_ptr->fd_parent_count; u++) {
+                parent_ptr = entry_ptr->flush_dep_parent[u];
+
+                HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                if (parent_ptr->include_in_image && parent_ptr->image_fd_height <= 0)
+                    H5C__prep_for_file_close__compute_fd_heights_real(parent_ptr, 1);
+            } /* end for */
+        }     /* end if */
 
         entry_ptr = entry_ptr->il_next;
     } /* while (entry_ptr != NULL) */
@@ -2573,7 +2536,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__prep_for_file_close__compute_fd_heights() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__prep_for_file_close__compute_fd_heights_real
  *
@@ -2623,8 +2585,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static void
-H5C__prep_for_file_close__compute_fd_heights_real(H5C_cache_entry_t  *entry_ptr,
-    uint32_t fd_height)
+H5C__prep_for_file_close__compute_fd_heights_real(H5C_cache_entry_t *entry_ptr, uint32_t fd_height)
 {
     FUNC_ENTER_STATIC_NOERR
 
@@ -2633,28 +2594,28 @@ H5C__prep_for_file_close__compute_fd_heights_real(H5C_cache_entry_t  *entry_ptr,
     HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
     HDassert(entry_ptr->include_in_image);
     HDassert((entry_ptr->image_fd_height == 0) || (entry_ptr->image_fd_height < fd_height));
-    HDassert(((fd_height == 0) && (entry_ptr->fd_child_count == 0)) || ((fd_height > 0) && (entry_ptr->fd_child_count > 0)));
+    HDassert(((fd_height == 0) && (entry_ptr->fd_child_count == 0)) ||
+             ((fd_height > 0) && (entry_ptr->fd_child_count > 0)));
 
     entry_ptr->image_fd_height = fd_height;
-    if(entry_ptr->flush_dep_nparents > 0) {
+    if (entry_ptr->flush_dep_nparents > 0) {
         unsigned u;
 
-	HDassert(entry_ptr->flush_dep_parent);
-	for(u = 0; u < entry_ptr->fd_parent_count; u++) {
+        HDassert(entry_ptr->flush_dep_parent);
+        for (u = 0; u < entry_ptr->fd_parent_count; u++) {
             H5C_cache_entry_t *parent_ptr;
 
-	    parent_ptr = entry_ptr->flush_dep_parent[u];
-	    HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+            parent_ptr = entry_ptr->flush_dep_parent[u];
+            HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
-	    if(parent_ptr->include_in_image && parent_ptr->image_fd_height <= fd_height)
-		H5C__prep_for_file_close__compute_fd_heights_real(parent_ptr, fd_height + 1);
+            if (parent_ptr->include_in_image && parent_ptr->image_fd_height <= fd_height)
+                H5C__prep_for_file_close__compute_fd_heights_real(parent_ptr, fd_height + 1);
         } /* end for */
-    } /* end if */
+    }     /* end if */
 
     FUNC_LEAVE_NOAPI_VOID
 } /* H5C__prep_for_file_close__compute_fd_heights_real() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__prep_for_file_close__setup_image_entries_array
  *
@@ -2672,11 +2633,11 @@ H5C__prep_for_file_close__compute_fd_heights_real(H5C_cache_entry_t  *entry_ptr,
 static herr_t
 H5C__prep_for_file_close__setup_image_entries_array(H5C_t *cache_ptr)
 {
-    H5C_cache_entry_t * entry_ptr;
-    H5C_image_entry_t * image_entries = NULL;
-    uint32_t		entries_visited = 0;
-    unsigned            u;                      /* Local index variable */
-    herr_t		ret_value = SUCCEED;    /* Return value */
+    H5C_cache_entry_t *entry_ptr;
+    H5C_image_entry_t *image_entries   = NULL;
+    uint32_t           entries_visited = 0;
+    unsigned           u;                   /* Local index variable */
+    herr_t             ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -2689,73 +2650,73 @@ H5C__prep_for_file_close__setup_image_entries_array(H5C_t *cache_ptr)
     HDassert(cache_ptr->image_entries == NULL);
 
     /* Allocate and initialize image_entries array */
-    if(NULL == (image_entries = (H5C_image_entry_t *)H5MM_calloc(sizeof(H5C_image_entry_t) * (size_t)(cache_ptr->num_entries_in_image + 1))))
+    if (NULL == (image_entries = (H5C_image_entry_t *)H5MM_calloc(
+                     sizeof(H5C_image_entry_t) * (size_t)(cache_ptr->num_entries_in_image + 1))))
         HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for image_entries")
 
     /* Initialize (non-zero/NULL/FALSE) fields */
-    for(u = 0; u <= cache_ptr->num_entries_in_image; u++) {
-	image_entries[u].magic                = H5C_IMAGE_ENTRY_T_MAGIC;
-	image_entries[u].addr                 = HADDR_UNDEF;
-        image_entries[u].ring		      = H5C_RING_UNDEFINED;
-	image_entries[u].type_id              = -1;
+    for (u = 0; u <= cache_ptr->num_entries_in_image; u++) {
+        image_entries[u].magic   = H5C_IMAGE_ENTRY_T_MAGIC;
+        image_entries[u].addr    = HADDR_UNDEF;
+        image_entries[u].ring    = H5C_RING_UNDEFINED;
+        image_entries[u].type_id = -1;
     } /* end for */
 
     /* Scan each entry on the index list and populate the image_entries array */
-    u = 0;
+    u         = 0;
     entry_ptr = cache_ptr->il_head;
-    while(entry_ptr != NULL) {
-	HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+    while (entry_ptr != NULL) {
+        HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
-        if(entry_ptr->include_in_image) {
-	    /* Since we have already serialized the cache, the following
+        if (entry_ptr->include_in_image) {
+            /* Since we have already serialized the cache, the following
              * should hold.
              */
             HDassert(entry_ptr->image_up_to_date);
             HDassert(entry_ptr->image_ptr);
-	    HDassert(entry_ptr->type);
+            HDassert(entry_ptr->type);
 
-	    image_entries[u].addr                 = entry_ptr->addr;
-	    image_entries[u].size                 = entry_ptr->size;
-	    image_entries[u].ring                 = entry_ptr->ring;
+            image_entries[u].addr = entry_ptr->addr;
+            image_entries[u].size = entry_ptr->size;
+            image_entries[u].ring = entry_ptr->ring;
 
-	    /* When a prefetched entry is included in the image, store
+            /* When a prefetched entry is included in the image, store
              * its underlying type id in the image entry, not
              * H5AC_PREFETCHED_ENTRY_ID.  In passing, also increment
-	     * the age (up to H5AC__CACHE_IMAGE__ENTRY_AGEOUT__MAX).
+             * the age (up to H5AC__CACHE_IMAGE__ENTRY_AGEOUT__MAX).
              */
-	    if(entry_ptr->type->id == H5AC_PREFETCHED_ENTRY_ID) {
-		image_entries[u].type_id          = entry_ptr->prefetch_type_id;
-		image_entries[u].age              = entry_ptr->age + 1;
+            if (entry_ptr->type->id == H5AC_PREFETCHED_ENTRY_ID) {
+                image_entries[u].type_id = entry_ptr->prefetch_type_id;
+                image_entries[u].age     = entry_ptr->age + 1;
 
-		if(image_entries[u].age > H5AC__CACHE_IMAGE__ENTRY_AGEOUT__MAX)
-		    image_entries[u].age = H5AC__CACHE_IMAGE__ENTRY_AGEOUT__MAX;
-	    } /* end if */
+                if (image_entries[u].age > H5AC__CACHE_IMAGE__ENTRY_AGEOUT__MAX)
+                    image_entries[u].age = H5AC__CACHE_IMAGE__ENTRY_AGEOUT__MAX;
+            } /* end if */
             else {
-                image_entries[u].type_id          = entry_ptr->type->id;
-		image_entries[u].age              = 0;
-	    } /* end else */
-
-	    image_entries[u].lru_rank             = entry_ptr->lru_rank;
-	    image_entries[u].is_dirty             = entry_ptr->is_dirty;
-	    image_entries[u].image_fd_height      = entry_ptr->image_fd_height;
-	    image_entries[u].fd_parent_count      = entry_ptr->fd_parent_count;
-	    image_entries[u].fd_parent_addrs      = entry_ptr->fd_parent_addrs;
-	    image_entries[u].fd_child_count       = entry_ptr->fd_child_count;
-	    image_entries[u].fd_dirty_child_count =
-						entry_ptr->fd_dirty_child_count;
-	    image_entries[u].image_ptr            = entry_ptr->image_ptr;
-
-	    /* Null out entry_ptr->fd_parent_addrs and set
+                image_entries[u].type_id = entry_ptr->type->id;
+                image_entries[u].age     = 0;
+            } /* end else */
+
+            image_entries[u].lru_rank             = entry_ptr->lru_rank;
+            image_entries[u].is_dirty             = entry_ptr->is_dirty;
+            image_entries[u].image_fd_height      = entry_ptr->image_fd_height;
+            image_entries[u].fd_parent_count      = entry_ptr->fd_parent_count;
+            image_entries[u].fd_parent_addrs      = entry_ptr->fd_parent_addrs;
+            image_entries[u].fd_child_count       = entry_ptr->fd_child_count;
+            image_entries[u].fd_dirty_child_count = entry_ptr->fd_dirty_child_count;
+            image_entries[u].image_ptr            = entry_ptr->image_ptr;
+
+            /* Null out entry_ptr->fd_parent_addrs and set
              * entry_ptr->fd_parent_count to zero so that ownership of the
              * flush dependency parents address array is transferred to the
-	     * image entry.
+             * image entry.
              */
-	    entry_ptr->fd_parent_count = 0;
-	    entry_ptr->fd_parent_addrs = NULL;
+            entry_ptr->fd_parent_count = 0;
+            entry_ptr->fd_parent_addrs = NULL;
 
             u++;
 
-	    HDassert(u <= cache_ptr->num_entries_in_image);
+            HDassert(u <= cache_ptr->num_entries_in_image);
         } /* end if */
 
         entries_visited++;
@@ -2776,7 +2737,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__prep_for_file_close__setup_image_entries_array() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__prep_for_file_close__scan_entries
  *
@@ -2810,18 +2770,18 @@ done:
 static herr_t
 H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr)
 {
-    H5C_cache_entry_t * entry_ptr;
-    hbool_t		include_in_image;
-    unsigned		entries_visited = 0;
-    int			lru_rank = 1;
-    uint32_t		num_entries_tentatively_in_image = 0;
-    uint32_t		num_entries_in_image = 0;
-    size_t		image_len;
-    size_t		entry_header_len;
-    size_t		fd_parents_list_len;
-    int			i;
-    unsigned            j;
-    herr_t		ret_value = SUCCEED;      /* Return value */
+    H5C_cache_entry_t *entry_ptr;
+    hbool_t            include_in_image;
+    unsigned           entries_visited                  = 0;
+    int                lru_rank                         = 1;
+    uint32_t           num_entries_tentatively_in_image = 0;
+    uint32_t           num_entries_in_image             = 0;
+    size_t             image_len;
+    size_t             entry_header_len;
+    size_t             fd_parents_list_len;
+    int                i;
+    unsigned           j;
+    herr_t             ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -2842,85 +2802,87 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr)
 
     /* Scan each entry on the index list */
     entry_ptr = cache_ptr->il_head;
-    while(entry_ptr != NULL) {
-	HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+    while (entry_ptr != NULL) {
+        HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
-	/* Since we have already serialized the cache, the following
+        /* Since we have already serialized the cache, the following
          * should hold.
          */
         HDassert(entry_ptr->image_up_to_date);
         HDassert(entry_ptr->image_ptr);
 
-	/* Initially, we mark all entries in the rings included
+        /* Initially, we mark all entries in the rings included
          * in the cache image as being included in the in the
          * image.  Depending on circumstances, we may exclude some
          * of these entries later.
          */
-	if(entry_ptr->ring > H5C_MAX_RING_IN_IMAGE)
-	    include_in_image = FALSE;
+        if (entry_ptr->ring > H5C_MAX_RING_IN_IMAGE)
+            include_in_image = FALSE;
         else
-	    include_in_image = TRUE;
+            include_in_image = TRUE;
         entry_ptr->include_in_image = include_in_image;
 
-        if(include_in_image) {
-	    entry_ptr->lru_rank = -1;
-            entry_ptr->image_dirty = entry_ptr->is_dirty;
-	    entry_ptr->image_fd_height = 0;     /* will compute this later */
+        if (include_in_image) {
+            entry_ptr->lru_rank        = -1;
+            entry_ptr->image_dirty     = entry_ptr->is_dirty;
+            entry_ptr->image_fd_height = 0; /* will compute this later */
 
-	    /* Initially, include all flush dependency parents in the
+            /* Initially, include all flush dependency parents in the
              * the list of flush dependencies to be stored in the
              * image.  We may remove some or all of these later.
              */
-	    if(entry_ptr->flush_dep_nparents > 0) {
-	        /* The parents addresses array may already exist -- reallocate
+            if (entry_ptr->flush_dep_nparents > 0) {
+                /* The parents addresses array may already exist -- reallocate
                  * as needed.
                  */
-		if(entry_ptr->flush_dep_nparents == entry_ptr->fd_parent_count ) {
-		    /* parent addresses array should already be allocated
+                if (entry_ptr->flush_dep_nparents == entry_ptr->fd_parent_count) {
+                    /* parent addresses array should already be allocated
                      * and of the correct size.
                      */
-		    HDassert(entry_ptr->fd_parent_addrs);
-		} /* end if */
-                else if(entry_ptr->fd_parent_count > 0) {
-		    HDassert(entry_ptr->fd_parent_addrs);
+                    HDassert(entry_ptr->fd_parent_addrs);
+                } /* end if */
+                else if (entry_ptr->fd_parent_count > 0) {
+                    HDassert(entry_ptr->fd_parent_addrs);
                     entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_xfree(entry_ptr->fd_parent_addrs);
-		} /* end else-if */
+                } /* end else-if */
                 else {
-		    HDassert(entry_ptr->fd_parent_count == 0);
-		    HDassert(entry_ptr->fd_parent_addrs == NULL);
-		} /* end else */
-
-		entry_ptr->fd_parent_count = entry_ptr->flush_dep_nparents;
-		if(NULL == entry_ptr->fd_parent_addrs)
-		    if(NULL == (entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_malloc(sizeof(haddr_t) * (size_t)(entry_ptr->fd_parent_count))))
-        	        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for fd parent addrs buffer")
-
-		for(i = 0; i < (int)(entry_ptr->fd_parent_count); i++) {
-		    entry_ptr->fd_parent_addrs[i] = entry_ptr->flush_dep_parent[i]->addr;
-		    HDassert(H5F_addr_defined(entry_ptr->fd_parent_addrs[i]));
-		} /* end for */
-            } /* end if */
-            else if(entry_ptr->fd_parent_count > 0) {
-		HDassert(entry_ptr->fd_parent_addrs);
-		entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_xfree(entry_ptr->fd_parent_addrs);
-	    } /* end else-if */
+                    HDassert(entry_ptr->fd_parent_count == 0);
+                    HDassert(entry_ptr->fd_parent_addrs == NULL);
+                } /* end else */
+
+                entry_ptr->fd_parent_count = entry_ptr->flush_dep_nparents;
+                if (NULL == entry_ptr->fd_parent_addrs)
+                    if (NULL == (entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_malloc(
+                                     sizeof(haddr_t) * (size_t)(entry_ptr->fd_parent_count))))
+                        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL,
+                                    "memory allocation failed for fd parent addrs buffer")
+
+                for (i = 0; i < (int)(entry_ptr->fd_parent_count); i++) {
+                    entry_ptr->fd_parent_addrs[i] = entry_ptr->flush_dep_parent[i]->addr;
+                    HDassert(H5F_addr_defined(entry_ptr->fd_parent_addrs[i]));
+                } /* end for */
+            }     /* end if */
+            else if (entry_ptr->fd_parent_count > 0) {
+                HDassert(entry_ptr->fd_parent_addrs);
+                entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_xfree(entry_ptr->fd_parent_addrs);
+            } /* end else-if */
             else
-		HDassert(entry_ptr->fd_parent_addrs == NULL);
+                HDassert(entry_ptr->fd_parent_addrs == NULL);
 
-	    /* Initially, all flush dependency children are included int
+            /* Initially, all flush dependency children are included int
              * the count of flush dependency child relationships to be
              * represented in the cache image.  Some or all of these
              * may be dropped from the image later.
              */
-	    if(entry_ptr->flush_dep_nchildren > 0) {
-		if(!entry_ptr->is_pinned)
+            if (entry_ptr->flush_dep_nchildren > 0) {
+                if (!entry_ptr->is_pinned)
                     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "encountered unpinned fd parent?!?")
 
-		entry_ptr->fd_child_count = entry_ptr->flush_dep_nchildren;
-		entry_ptr->fd_dirty_child_count = entry_ptr->flush_dep_ndirty_children;
-	    } /* end if */
+                entry_ptr->fd_child_count       = entry_ptr->flush_dep_nchildren;
+                entry_ptr->fd_dirty_child_count = entry_ptr->flush_dep_ndirty_children;
+            } /* end if */
 
-	    num_entries_tentatively_in_image++;
+            num_entries_tentatively_in_image++;
         } /* end if */
 
         entries_visited++;
@@ -2951,7 +2913,7 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr)
      * exact contents of the image cannot be known until after this
      * call, computation of the image size is delayed.
      */
-    if(H5C__prep_for_file_close__compute_fd_heights(cache_ptr) < 0)
+    if (H5C__prep_for_file_close__compute_fd_heights(cache_ptr) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "computation of flush dependency heights failed?!?")
 
     /* At this point, all entries that will appear in the cache
@@ -2959,12 +2921,12 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr)
      * cache image.
      */
     entries_visited = 0;
-    entry_ptr = cache_ptr->il_head;
-    while(entry_ptr != NULL) {
+    entry_ptr       = cache_ptr->il_head;
+    while (entry_ptr != NULL) {
         HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
-        if(entry_ptr->include_in_image) {
-            if(entry_ptr->fd_parent_count > 0)
+        if (entry_ptr->include_in_image) {
+            if (entry_ptr->fd_parent_count > 0)
                 fd_parents_list_len = (size_t)(H5F_SIZEOF_ADDR(f) * entry_ptr->fd_parent_count);
             else
                 fd_parents_list_len = (size_t)0;
@@ -2980,14 +2942,14 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr)
     HDassert(num_entries_in_image <= num_entries_tentatively_in_image);
 
     j = 0;
-    for(i = H5C_MAX_RING_IN_IMAGE + 1; i <= H5C_RING_SB; i++)
+    for (i = H5C_MAX_RING_IN_IMAGE + 1; i <= H5C_RING_SB; i++)
         j += cache_ptr->index_ring_len[i];
 
     /* This will change */
     HDassert(entries_visited == (num_entries_tentatively_in_image + j));
 
     cache_ptr->num_entries_in_image = num_entries_in_image;
-    entries_visited = 0;
+    entries_visited                 = 0;
 
     /* Now scan the LRU list to set the lru_rank fields of all entries
      * on the LRU.
@@ -3000,8 +2962,8 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr)
      * the reconstructed LRU should be appropriate.
      */
     entry_ptr = cache_ptr->LRU_head_ptr;
-    while(entry_ptr != NULL) {
-	HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+    while (entry_ptr != NULL) {
+        HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
         HDassert(entry_ptr->type != NULL);
 
         /* to avoid confusion, don't set lru_rank on epoch markers.
@@ -3013,10 +2975,10 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr)
          * Do not set lru_rank or increment lru_rank for entries
          * that will not be included in the cache image.
          */
-	if(entry_ptr->type->id == H5AC_EPOCH_MARKER_ID)
-	    lru_rank++;
-	else if(entry_ptr->include_in_image) {
-	    entry_ptr->lru_rank = lru_rank;
+        if (entry_ptr->type->id == H5AC_EPOCH_MARKER_ID)
+            lru_rank++;
+        else if (entry_ptr->include_in_image) {
+            entry_ptr->lru_rank = lru_rank;
             lru_rank++;
         } /* end else-if */
 
@@ -3032,7 +2994,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__prep_for_file_close__scan_entries() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__reconstruct_cache_contents()
  *
@@ -3052,11 +3013,11 @@ done:
 static herr_t
 H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
 {
-    H5C_cache_entry_t *	pf_entry_ptr;   /* Pointer to prefetched entry */
-    H5C_cache_entry_t *	parent_ptr;     /* Pointer to parent of prefetched entry */
-    const uint8_t *	p;              /* Pointer into image buffer */
-    unsigned		u, v;           /* Local index variable */
-    herr_t 		ret_value = SUCCEED;      /* Return value */
+    H5C_cache_entry_t *pf_entry_ptr;        /* Pointer to prefetched entry */
+    H5C_cache_entry_t *parent_ptr;          /* Pointer to parent of prefetched entry */
+    const uint8_t *    p;                   /* Pointer into image buffer */
+    unsigned           u, v;                /* Local index variable */
+    herr_t             ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -3071,7 +3032,7 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
 
     /* Decode metadata cache image header */
     p = (uint8_t *)cache_ptr->image_buffer;
-    if(H5C__decode_cache_image_header(f, cache_ptr, &p) < 0)
+    if (H5C__decode_cache_image_header(f, cache_ptr, &p) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTDECODE, FAIL, "cache image header decode failed")
     HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) < cache_ptr->image_len);
 
@@ -3081,14 +3042,14 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
     HDassert(cache_ptr->num_entries_in_image > 0);
 
     /* Reconstruct entries in image */
-    for(u = 0; u < cache_ptr->num_entries_in_image; u++) {
-	/* Create the prefetched entry described by the ith
+    for (u = 0; u < cache_ptr->num_entries_in_image; u++) {
+        /* Create the prefetched entry described by the ith
          * entry in cache_ptr->image_entrise.
          */
-	if(NULL == (pf_entry_ptr = H5C__reconstruct_cache_entry(f, cache_ptr, &p)))
+        if (NULL == (pf_entry_ptr = H5C__reconstruct_cache_entry(f, cache_ptr, &p)))
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "reconstruction of cache entry failed")
 
-	/* Note that we make no checks on available cache space before
+        /* Note that we make no checks on available cache space before
          * inserting the reconstructed entry into the metadata cache.
          *
          * This is OK since the cache must be almost empty at the beginning
@@ -3096,66 +3057,66 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
          * reconstruction process.
          */
 
-	/* Insert the prefetched entry in the index */
-	H5C__INSERT_IN_INDEX(cache_ptr, pf_entry_ptr, FAIL)
+        /* Insert the prefetched entry in the index */
+        H5C__INSERT_IN_INDEX(cache_ptr, pf_entry_ptr, FAIL)
 
-	/* If dirty, insert the entry into the slist. */
-	if(pf_entry_ptr->is_dirty)
-	    H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, pf_entry_ptr, FAIL)
+        /* If dirty, insert the entry into the slist. */
+        if (pf_entry_ptr->is_dirty)
+            H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, pf_entry_ptr, FAIL)
 
         /* Append the entry to the LRU */
-	H5C__UPDATE_RP_FOR_INSERT_APPEND(cache_ptr, pf_entry_ptr, FAIL)
+        H5C__UPDATE_RP_FOR_INSERT_APPEND(cache_ptr, pf_entry_ptr, FAIL)
 
-	H5C__UPDATE_STATS_FOR_PREFETCH(cache_ptr, pf_entry_ptr->is_dirty)
+        H5C__UPDATE_STATS_FOR_PREFETCH(cache_ptr, pf_entry_ptr->is_dirty)
 
-	/* If the prefetched entry is the child in one or more flush
+        /* If the prefetched entry is the child in one or more flush
          * dependency relationships, recreate those flush dependencies.
          */
-	for(v = 0; v < pf_entry_ptr->fd_parent_count; v++) {
+        for (v = 0; v < pf_entry_ptr->fd_parent_count; v++) {
             /* Sanity checks */
-	    HDassert(pf_entry_ptr->fd_parent_addrs);
-	    HDassert(H5F_addr_defined(pf_entry_ptr->fd_parent_addrs[v]));
+            HDassert(pf_entry_ptr->fd_parent_addrs);
+            HDassert(H5F_addr_defined(pf_entry_ptr->fd_parent_addrs[v]));
 
             /* Find the parent entry */
-	    parent_ptr = NULL;
-	    H5C__SEARCH_INDEX(cache_ptr, pf_entry_ptr->fd_parent_addrs[v], parent_ptr, FAIL)
-	    if(parent_ptr == NULL)
+            parent_ptr = NULL;
+            H5C__SEARCH_INDEX(cache_ptr, pf_entry_ptr->fd_parent_addrs[v], parent_ptr, FAIL)
+            if (parent_ptr == NULL)
                 HGOTO_ERROR(H5E_CACHE, H5E_NOTFOUND, FAIL, "fd parent not in cache?!?")
 
             /* Sanity checks */
-	    HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+            HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
             HDassert(parent_ptr->addr == pf_entry_ptr->fd_parent_addrs[v]);
             HDassert(parent_ptr->lru_rank == -1);
 
-	    /* Must protect parent entry to set up a flush dependency.
+            /* Must protect parent entry to set up a flush dependency.
              * Do this now, and then uprotect when done.
              */
             H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, parent_ptr, FAIL)
             parent_ptr->is_protected = TRUE;
 
-	    /* Setup the flush dependency */
-	    if(H5C_create_flush_dependency(parent_ptr, pf_entry_ptr) < 0)
-		HGOTO_ERROR(H5E_CACHE, H5E_CANTDEPEND, FAIL, "Can't restore flush dependency")
+            /* Setup the flush dependency */
+            if (H5C_create_flush_dependency(parent_ptr, pf_entry_ptr) < 0)
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTDEPEND, FAIL, "Can't restore flush dependency")
 
-	    /* And now unprotect */
-	    H5C__UPDATE_RP_FOR_UNPROTECT(cache_ptr, parent_ptr, FAIL)
-	    parent_ptr->is_protected = FALSE;
+            /* And now unprotect */
+            H5C__UPDATE_RP_FOR_UNPROTECT(cache_ptr, parent_ptr, FAIL)
+            parent_ptr->is_protected = FALSE;
         } /* end for */
-    } /* end for */
+    }     /* end for */
 
 #ifndef NDEBUG
     /* Scan the cache entries, and verify that each entry has
      * the expected flush dependency status.
      */
     pf_entry_ptr = cache_ptr->il_head;
-    while(pf_entry_ptr != NULL) {
+    while (pf_entry_ptr != NULL) {
         HDassert(pf_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-        HDassert((pf_entry_ptr->prefetched && pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY)
-            || (!pf_entry_ptr->prefetched && pf_entry_ptr->type != H5AC_PREFETCHED_ENTRY));
-        if(pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY)
+        HDassert((pf_entry_ptr->prefetched && pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY) ||
+                 (!pf_entry_ptr->prefetched && pf_entry_ptr->type != H5AC_PREFETCHED_ENTRY));
+        if (pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY)
             HDassert(pf_entry_ptr->fd_parent_count == pf_entry_ptr->flush_dep_nparents);
 
-        for(v = 0; v < pf_entry_ptr->fd_parent_count; v++) {
+        for (v = 0; v < pf_entry_ptr->fd_parent_count; v++) {
             parent_ptr = pf_entry_ptr->flush_dep_parent[v];
             HDassert(parent_ptr);
             HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
@@ -3164,7 +3125,7 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
             HDassert(parent_ptr->flush_dep_nchildren > 0);
         } /* end for */
 
-        if(pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY) {
+        if (pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY) {
             HDassert(pf_entry_ptr->fd_child_count == pf_entry_ptr->flush_dep_nchildren);
             HDassert(pf_entry_ptr->fd_dirty_child_count == pf_entry_ptr->flush_dep_ndirty_children);
         } /* end if */
@@ -3176,26 +3137,24 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
      * prefetched entries.
      */
     {
-	int lru_rank_holes = 0;
+        int                lru_rank_holes = 0;
         H5C_cache_entry_t *entry_ptr;
-        int     i;              /* Local index variable */
+        int                i; /* Local index variable */
 
-        i = -1;
+        i         = -1;
         entry_ptr = cache_ptr->LRU_head_ptr;
 
-        while(entry_ptr != NULL) {
+        while (entry_ptr != NULL) {
 
             HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
             HDassert(entry_ptr->type != NULL);
 
-            if ( entry_ptr->prefetched ) {
+            if (entry_ptr->prefetched) {
 
                 HDassert(entry_ptr->lru_rank != 0);
-                HDassert((entry_ptr->lru_rank == -1) ||
-                         (entry_ptr->lru_rank > i));
+                HDassert((entry_ptr->lru_rank == -1) || (entry_ptr->lru_rank > i));
 
-                if ( ( entry_ptr->lru_rank > 1 ) &&
-                     ( entry_ptr->lru_rank > i + 1 ) )
+                if ((entry_ptr->lru_rank > 1) && (entry_ptr->lru_rank > i + 1))
 
                     lru_rank_holes += entry_ptr->lru_rank - (i + 1);
 
@@ -3206,41 +3165,40 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
             entry_ptr = entry_ptr->next;
         } /* end while */
 
-	/* Holes in the sequences of LRU ranks can appear due to epoch
+        /* Holes in the sequences of LRU ranks can appear due to epoch
          * markers.  They are left in to allow re-insertion of the
          * epoch markers on reconstruction of the cache -- thus
          * the following sanity check will have to be revised when
          * we add code to store and restore adaptive resize status.
          */
-	HDassert(lru_rank_holes <= H5C__MAX_EPOCH_MARKERS);
-    } /* end block */
+        HDassert(lru_rank_holes <= H5C__MAX_EPOCH_MARKERS);
+    }  /* end block */
 #endif /* NDEBUG */
 
     /* Check to see if the cache is oversize, and evict entries as
      * necessary to remain within limits.
      */
-    if(cache_ptr->index_size >= cache_ptr->max_cache_size) {
-	/* cache is oversized -- call H5C__make_space_in_cache() with zero
+    if (cache_ptr->index_size >= cache_ptr->max_cache_size) {
+        /* cache is oversized -- call H5C__make_space_in_cache() with zero
          * space needed to repair the situation if possible.
          */
         hbool_t write_permitted = FALSE;
 
-	if(cache_ptr->check_write_permitted != NULL) {
-	    if((cache_ptr->check_write_permitted)(f, &write_permitted) < 0)
+        if (cache_ptr->check_write_permitted != NULL) {
+            if ((cache_ptr->check_write_permitted)(f, &write_permitted) < 0)
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, FAIL, "Can't get write_permitted")
         } /* end if */
         else
             write_permitted = cache_ptr->write_permitted;
 
-	if(H5C__make_space_in_cache(f, 0, write_permitted) < 0)
-	    HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, FAIL, "H5C__make_space_in_cache failed")
+        if (H5C__make_space_in_cache(f, 0, write_permitted) < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, FAIL, "H5C__make_space_in_cache failed")
     } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__reconstruct_cache_contents() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__reconstruct_cache_entry()
  *
@@ -3259,20 +3217,19 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5C_cache_entry_t *
-H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr,
-    const uint8_t **buf)
+H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **buf)
 {
-    H5C_cache_entry_t *pf_entry_ptr = NULL;     /* Reconstructed cache entry */
-    uint8_t             flags = 0;
-    hbool_t		is_dirty = FALSE;
-#ifndef NDEBUG	/* only used in assertions */
-    hbool_t		in_lru = FALSE;
-    hbool_t		is_fd_parent = FALSE;
-    hbool_t		is_fd_child = FALSE;
+    H5C_cache_entry_t *pf_entry_ptr = NULL; /* Reconstructed cache entry */
+    uint8_t            flags        = 0;
+    hbool_t            is_dirty     = FALSE;
+#ifndef NDEBUG /* only used in assertions */
+    hbool_t in_lru       = FALSE;
+    hbool_t is_fd_parent = FALSE;
+    hbool_t is_fd_child  = FALSE;
 #endif /* NDEBUG */ /* only used in assertions */
-    const uint8_t *	p;
+    const uint8_t *    p;
     hbool_t            file_is_rw;
-    H5C_cache_entry_t *ret_value = NULL;        /* Return value */
+    H5C_cache_entry_t *ret_value = NULL; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -3286,8 +3243,8 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr,
     file_is_rw = cache_ptr->delete_image;
 
     /* Allocate space for the prefetched cache entry */
-    if(NULL == (pf_entry_ptr = H5FL_CALLOC(H5C_cache_entry_t)))
-	HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for prefetched cache entry")
+    if (NULL == (pf_entry_ptr = H5FL_CALLOC(H5C_cache_entry_t)))
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for prefetched cache entry")
 
     /* Get pointer to buffer */
     p = *buf;
@@ -3297,14 +3254,14 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr,
 
     /* Decode flags */
     flags = *p++;
-    if(flags & H5C__MDCI_ENTRY_DIRTY_FLAG)
+    if (flags & H5C__MDCI_ENTRY_DIRTY_FLAG)
         is_dirty = TRUE;
-#ifndef NDEBUG	/* only used in assertions */
-    if(flags & H5C__MDCI_ENTRY_IN_LRU_FLAG)
+#ifndef NDEBUG /* only used in assertions */
+    if (flags & H5C__MDCI_ENTRY_IN_LRU_FLAG)
         in_lru = TRUE;
-    if(flags & H5C__MDCI_ENTRY_IS_FD_PARENT_FLAG)
+    if (flags & H5C__MDCI_ENTRY_IS_FD_PARENT_FLAG)
         is_fd_parent = TRUE;
-    if(flags & H5C__MDCI_ENTRY_IS_FD_CHILD_FLAG)
+    if (flags & H5C__MDCI_ENTRY_IS_FD_CHILD_FLAG)
         is_fd_child = TRUE;
 #endif /* NDEBUG */ /* only used in assertions */
 
@@ -3332,18 +3289,20 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr,
 
     /* Decode dependency child count */
     UINT16DECODE(p, pf_entry_ptr->fd_child_count);
-    HDassert((is_fd_parent && pf_entry_ptr->fd_child_count > 0) || (!is_fd_parent && pf_entry_ptr->fd_child_count == 0));
+    HDassert((is_fd_parent && pf_entry_ptr->fd_child_count > 0) ||
+             (!is_fd_parent && pf_entry_ptr->fd_child_count == 0));
 
     /* Decode dirty dependency child count */
     UINT16DECODE(p, pf_entry_ptr->fd_dirty_child_count);
-    if(!file_is_rw)
-        pf_entry_ptr->fd_dirty_child_count      = 0;
-    if(pf_entry_ptr->fd_dirty_child_count > pf_entry_ptr->fd_child_count)
+    if (!file_is_rw)
+        pf_entry_ptr->fd_dirty_child_count = 0;
+    if (pf_entry_ptr->fd_dirty_child_count > pf_entry_ptr->fd_child_count)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "invalid dirty flush dependency child count")
 
     /* Decode dependency parent count */
     UINT16DECODE(p, pf_entry_ptr->fd_parent_count);
-    HDassert((is_fd_child && pf_entry_ptr->fd_parent_count > 0) || (!is_fd_child && pf_entry_ptr->fd_parent_count == 0));
+    HDassert((is_fd_child && pf_entry_ptr->fd_parent_count > 0) ||
+             (!is_fd_child && pf_entry_ptr->fd_parent_count == 0));
 
     /* Decode index in LRU */
     INT32DECODE(p, pf_entry_ptr->lru_rank);
@@ -3351,37 +3310,38 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr,
 
     /* Decode entry offset */
     H5F_addr_decode(f, &p, &pf_entry_ptr->addr);
-    if(!H5F_addr_defined(pf_entry_ptr->addr))
+    if (!H5F_addr_defined(pf_entry_ptr->addr))
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "invalid entry offset")
 
     /* Decode entry length */
     H5F_DECODE_LENGTH(f, p, pf_entry_ptr->size);
-    if(pf_entry_ptr->size == 0)
+    if (pf_entry_ptr->size == 0)
         HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "invalid entry size")
 
     /* Verify expected length of entry image */
-    if((size_t)(p - *buf) != H5C__cache_image_block_entry_header_size(f))
+    if ((size_t)(p - *buf) != H5C__cache_image_block_entry_header_size(f))
         HGOTO_ERROR(H5E_CACHE, H5E_BADSIZE, NULL, "Bad entry image len")
 
     /* If parent count greater than zero, allocate array for parent
      * addresses, and decode addresses into the array.
      */
-    if(pf_entry_ptr->fd_parent_count > 0) {
-        unsigned u;          /* Local index variable */
+    if (pf_entry_ptr->fd_parent_count > 0) {
+        unsigned u; /* Local index variable */
 
-        if(NULL == (pf_entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_malloc((size_t)(pf_entry_ptr->fd_parent_count) * H5F_SIZEOF_ADDR(f))))
-	    HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for fd parent addrs buffer")
+        if (NULL == (pf_entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_malloc(
+                         (size_t)(pf_entry_ptr->fd_parent_count) * H5F_SIZEOF_ADDR(f))))
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for fd parent addrs buffer")
 
-	for(u = 0; u < pf_entry_ptr->fd_parent_count; u++) {
+        for (u = 0; u < pf_entry_ptr->fd_parent_count; u++) {
             H5F_addr_decode(f, &p, &(pf_entry_ptr->fd_parent_addrs[u]));
-            if(!H5F_addr_defined(pf_entry_ptr->fd_parent_addrs[u]))
+            if (!H5F_addr_defined(pf_entry_ptr->fd_parent_addrs[u]))
                 HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "invalid flush dependency parent offset")
         } /* end for */
-    } /* end if */
+    }     /* end if */
 
     /* Allocate buffer for entry image */
-    if(NULL == (pf_entry_ptr->image_ptr = H5MM_malloc(pf_entry_ptr->size + H5C_IMAGE_EXTRA_SPACE)))
-	HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for on disk image buffer")
+    if (NULL == (pf_entry_ptr->image_ptr = H5MM_malloc(pf_entry_ptr->size + H5C_IMAGE_EXTRA_SPACE)))
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for on disk image buffer")
 #if H5C_DO_MEMORY_SANITY_CHECKS
     H5MM_memcpy(((uint8_t *)pf_entry_ptr->image_ptr) + size, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
@@ -3392,12 +3352,12 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr,
 
     /* Initialize the rest of the fields in the prefetched entry */
     /* (Only need to set non-zero/NULL/FALSE fields, due to calloc() above) */
-    pf_entry_ptr->magic				= H5C__H5C_CACHE_ENTRY_T_MAGIC;
-    pf_entry_ptr->cache_ptr 			= cache_ptr;
-    pf_entry_ptr->image_up_to_date		= TRUE;
-    pf_entry_ptr->type				= H5AC_PREFETCHED_ENTRY;
-    pf_entry_ptr->prefetched			= TRUE;
-    pf_entry_ptr->prefetched_dirty              = is_dirty && (!file_is_rw);
+    pf_entry_ptr->magic            = H5C__H5C_CACHE_ENTRY_T_MAGIC;
+    pf_entry_ptr->cache_ptr        = cache_ptr;
+    pf_entry_ptr->image_up_to_date = TRUE;
+    pf_entry_ptr->type             = H5AC_PREFETCHED_ENTRY;
+    pf_entry_ptr->prefetched       = TRUE;
+    pf_entry_ptr->prefetched_dirty = is_dirty && (!file_is_rw);
 
     /* Sanity checks */
     HDassert(pf_entry_ptr->size > 0 && pf_entry_ptr->size < H5C_MAX_ENTRY_SIZE);
@@ -3408,13 +3368,12 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr,
     ret_value = pf_entry_ptr;
 
 done:
-    if(NULL == ret_value && pf_entry_ptr)
+    if (NULL == ret_value && pf_entry_ptr)
         pf_entry_ptr = H5FL_FREE(H5C_cache_entry_t, pf_entry_ptr);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__reconstruct_cache_entry() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__write_cache_image_superblock_msg
  *
@@ -3435,12 +3394,12 @@ done:
 static herr_t
 H5C__write_cache_image_superblock_msg(H5F_t *f, hbool_t create)
 {
-    H5C_t *		cache_ptr;
-    H5O_mdci_t 	        mdci_msg;	/* metadata cache image message */
-					/* to insert in the superblock  */
-					/* extension.			*/
-    unsigned	   	mesg_flags = H5O_MSG_FLAG_FAIL_IF_UNKNOWN_ALWAYS;
-    herr_t              ret_value = SUCCEED;      /* Return value */
+    H5C_t *    cache_ptr;
+    H5O_mdci_t mdci_msg; /* metadata cache image message */
+                         /* to insert in the superblock  */
+                         /* extension.			*/
+    unsigned mesg_flags = H5O_MSG_FLAG_FAIL_IF_UNKNOWN_ALWAYS;
+    herr_t   ret_value  = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -3459,8 +3418,8 @@ H5C__write_cache_image_superblock_msg(H5F_t *f, hbool_t create)
      */
     mdci_msg.addr = cache_ptr->image_addr;
 #ifdef H5_HAVE_PARALLEL
-    if(cache_ptr->aux_ptr) { /* we have multiple processes */
-        H5AC_aux_t * aux_ptr;
+    if (cache_ptr->aux_ptr) { /* we have multiple processes */
+        H5AC_aux_t *aux_ptr;
 
         aux_ptr = (H5AC_aux_t *)cache_ptr->aux_ptr;
         HDassert(aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC);
@@ -3471,14 +3430,14 @@ H5C__write_cache_image_superblock_msg(H5F_t *f, hbool_t create)
         mdci_msg.size = cache_ptr->image_len;
 
     /* Write metadata cache image message to superblock extension */
-    if(H5F__super_ext_write_msg(f, H5O_MDCI_MSG_ID, &mdci_msg, create, mesg_flags) < 0)
-        HGOTO_ERROR(H5E_CACHE, H5E_WRITEERROR, FAIL, "can't write metadata cache image message to superblock extension")
+    if (H5F__super_ext_write_msg(f, H5O_MDCI_MSG_ID, &mdci_msg, create, mesg_flags) < 0)
+        HGOTO_ERROR(H5E_CACHE, H5E_WRITEERROR, FAIL,
+                    "can't write metadata cache image message to superblock extension")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__write_cache_image_superblock_msg() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5C__write_cache_image
  *
@@ -3495,7 +3454,7 @@ done:
 static herr_t
 H5C__write_cache_image(H5F_t *f, const H5C_t *cache_ptr)
 {
-    herr_t              ret_value = SUCCEED;    /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -3507,22 +3466,22 @@ H5C__write_cache_image(H5F_t *f, const H5C_t *cache_ptr)
     HDassert(cache_ptr->image_buffer);
 
 #ifdef H5_HAVE_PARALLEL
-{
-    H5AC_aux_t *aux_ptr = (H5AC_aux_t *)cache_ptr->aux_ptr;
+    {
+        H5AC_aux_t *aux_ptr = (H5AC_aux_t *)cache_ptr->aux_ptr;
 
-    if((NULL == aux_ptr) || (aux_ptr->mpi_rank == 0)) {
-	HDassert((NULL == aux_ptr) || (aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC));
+        if ((NULL == aux_ptr) || (aux_ptr->mpi_rank == 0)) {
+            HDassert((NULL == aux_ptr) || (aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC));
 #endif /* H5_HAVE_PARALLEL */
 
-	/* Write the buffer (if serial access, or rank 0 for parallel access) */
-	if(H5F_block_write(f, H5FD_MEM_SUPER, cache_ptr->image_addr, cache_ptr->image_len, cache_ptr->image_buffer) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't write metadata cache image block to file")
+            /* Write the buffer (if serial access, or rank 0 for parallel access) */
+            if (H5F_block_write(f, H5FD_MEM_SUPER, cache_ptr->image_addr, cache_ptr->image_len,
+                                cache_ptr->image_buffer) < 0)
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't write metadata cache image block to file")
 #ifdef H5_HAVE_PARALLEL
-    } /* end if */
-} /* end block */
-#endif /* H5_HAVE_PARALLEL */
+        } /* end if */
+    }     /* end block */
+#endif    /* H5_HAVE_PARALLEL */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C__write_cache_image() */
-