Trim trailing whitespace

1 files changed, 206 insertions, 206 deletions

diff --git a/src/H5C.c b/src/H5C.c
index 2a90bd1..91e4158 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -171,7 +171,7 @@ static herr_t H5C__verify_len_eoa(H5F_t *f, const H5C_class_t * type,
     haddr_t addr, size_t *len, hbool_t actual);
 
 #if H5C_DO_SLIST_SANITY_CHECKS
-static hbool_t H5C_entry_in_skip_list(H5C_t * cache_ptr, 
+static hbool_t H5C_entry_in_skip_list(H5C_t * cache_ptr,
                                       H5C_cache_entry_t *target_ptr);
 #endif /* H5C_DO_SLIST_SANITY_CHECKS */
 
@@ -722,10 +722,10 @@ H5C_free_tag_list_cb(void *_item, void H5_ATTR_UNUSED *key, void H5_ATTR_UNUSED
  *
  * Function:    H5C_prep_for_file_close
  *
- * Purpose:     This function should be called just prior to the cache 
- *		flushes at file close.  There should be no protected 
+ * Purpose:     This function should be called just prior to the cache
+ *		flushes at file close.  There should be no protected
  *		entries in the cache at this point.
- *		
+ *
  * Return:      Non-negative on success/Negative on failure
  *
  * Programmer:  John Mainzer
@@ -750,8 +750,8 @@ H5C_prep_for_file_close(H5F_t *f)
     HDassert(cache_ptr);
     HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
 
-    /* For now at least, it is possible to receive the 
-     * close warning more than once -- the following 
+    /* For now at least, it is possible to receive the
+     * close warning more than once -- the following
      * if statement handles this.
      */
     if(cache_ptr->close_warning_received)
@@ -767,8 +767,8 @@ H5C_prep_for_file_close(H5F_t *f)
 
 #ifdef H5_HAVE_PARALLEL
     if ( ( H5F_INTENT(f) & H5F_ACC_RDWR ) &&
-         ( ! image_generated ) && 
-         ( cache_ptr->aux_ptr != NULL ) && 
+         ( ! image_generated ) &&
+         ( cache_ptr->aux_ptr != NULL ) &&
          ( f->shared->fs_persist ) ) {
         /* If persistent free space managers are enabled, flushing the
          * metadata cache may result in the deletion, insertion, and/or
@@ -1011,31 +1011,31 @@ done:
  * Programmer:  John Mainzer
  *		6/2/04
  *
- * Changes:	Modified function to test for slist chamges in 
+ * Changes:	Modified function to test for slist chamges in
  *		pre_serialize and serialize callbacks, and re-start
  *		scans through the slist when such changes occur.
  *
  *		This has been a potential problem for some time,
- *		and there has been code in this function to deal 
- *		with elements of this issue.  However the shift 
+ *		and there has been code in this function to deal
+ *		with elements of this issue.  However the shift
  *		to the V3 cache in combination with the activities
- *		of some of the cache clients (in particular the 
+ *		of some of the cache clients (in particular the
  *		free space manager and the fractal heap) have
  *		made this re-work necessary.
  *
  *						JRM -- 12/13/14
  *
- *		Modified function to support rings.  Basic idea is that 
+ *		Modified function to support rings.  Basic idea is that
  *		every entry in the cache is assigned to a ring.  Entries
- *		in the outermost ring are flushed first, followed by 
- *		those in the next outermost ring, and so on until the 
- *		innermost ring is flushed.  See header comment on 
- *		H5C_ring_t in H5Cprivate.h for a more detailed 
+ *		in the outermost ring are flushed first, followed by
+ *		those in the next outermost ring, and so on until the
+ *		innermost ring is flushed.  See header comment on
+ *		H5C_ring_t in H5Cprivate.h for a more detailed
  *		discussion.
  *
  *						JRM -- 8/30/15
  *
- *		Modified function to call the free space manager 
+ *		Modified function to call the free space manager
  *		settling functions.
  *						JRM -- 6/9/16
  *
@@ -1111,7 +1111,7 @@ H5C_flush_cache(H5F_t *f, unsigned flags)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush invalidate failed")
     } /* end if */
     else {
-	/* flush each ring, starting from the outermost ring and 
+	/* flush each ring, starting from the outermost ring and
          * working inward.
          */
         ring = H5C_RING_USER;
@@ -2245,7 +2245,7 @@ H5C_protect(H5F_t *		f,
 
         if(entry_ptr->prefetched) {
             /* This call removes the prefetched entry from the cache,
-             * and replaces it with an entry deserialized from the 
+             * and replaces it with an entry deserialized from the
              * image of the prefetched entry.
              */
             if(H5C__deserialize_prefetched_entry(f, cache_ptr, &entry_ptr, type, addr, udata) < 0)
@@ -2314,7 +2314,7 @@ H5C_protect(H5F_t *		f,
         if(cache_ptr->ignore_tags != TRUE) {
             haddr_t tag;              /* Tag value */
 
-            /* The entry is already in the cache, but make sure that the tag value 
+            /* The entry is already in the cache, but make sure that the tag value
              * is still legal. This will ensure that had the entry NOT been in the
              * cache, tagging was still set up correctly and it would have received
              * a legal tag value after getting loaded from disk.
@@ -2322,7 +2322,7 @@ H5C_protect(H5F_t *		f,
 
             /* Get the tag */
             tag = H5CX_get_tag();
-    
+
             if(H5C_verify_tag(entry_ptr->type->id, tag) < 0)
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, NULL, "tag verification failed")
         } /* end if */
@@ -2338,9 +2338,9 @@ H5C_protect(H5F_t *		f,
 
         hit = FALSE;
 
-        if(NULL == (thing = H5C_load_entry(f, 
+        if(NULL == (thing = H5C_load_entry(f,
 #ifdef H5_HAVE_PARALLEL
-                                           coll_access, 
+                                           coll_access,
 #endif /* H5_HAVE_PARALLEL */
                                            type, addr, udata)))
             HGOTO_ERROR(H5E_CACHE, H5E_CANTLOAD, NULL, "can't load entry")
@@ -2449,12 +2449,12 @@ H5C_protect(H5F_t *		f,
          *   *******************************************
          *
          * Set the flush_last field
- 	 * of the newly loaded entry before inserting it into the 
-         * index.  Must do this, as the index tracked the number of 
-         * entries with the flush_last field set, but assumes that 
+ 	 * of the newly loaded entry before inserting it into the
+         * index.  Must do this, as the index tracked the number of
+         * entries with the flush_last field set, but assumes that
          * the field will not change after insertion into the index.
          *
-         * Note that this means that the H5C__FLUSH_LAST_FLAG flag 
+         * Note that this means that the H5C__FLUSH_LAST_FLAG flag
          * is ignored if the entry is already in cache.
          */
         entry_ptr->flush_me_last = flush_last;
@@ -2486,7 +2486,7 @@ H5C_protect(H5F_t *		f,
 	    HDassert(entry_ptr->ro_ref_count > 0);
 	    (entry_ptr->ro_ref_count)++;
 	} /* end if */
-        else 
+        else
             HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "Target already protected & not read only?!?")
     } /* end if */
     else {
@@ -2890,7 +2890,7 @@ done:
  *              3/22/06
  *
  * Changes:	Added extreme sanity checks on entry and exit.
-                				JRM -- 4/26/14 
+                				JRM -- 4/26/14
  *
  *-------------------------------------------------------------------------
  */
@@ -3112,7 +3112,7 @@ H5C_unprotect(H5F_t *f, haddr_t	addr, void *thing, unsigned flags)
             if(entry_ptr->flush_dep_nparents > 0)
                 if(H5C__mark_flush_dep_dirty(entry_ptr) < 0)
                     HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "Can't propagate flush dep dirty flag")
-        } /* end if */ 
+        } /* end if */
         /* Check for newly clean entry */
         else if(!was_clean && !entry_ptr->is_dirty) {
             /* If the entry's type has a 'notify' callback send a 'entry cleaned'
@@ -3969,8 +3969,8 @@ H5C__auto_adjust_cache_size(H5F_t *f, hbool_t write_permitted)
     HDassert( (cache_ptr->resize_ctl).min_clean_fraction <= (double)100.0f );
 
     /* check to see if cache_ptr->resize_in_progress is TRUE.  If it, this
-     * is a re-entrant call via a client callback called in the resize 
-     * process.  To avoid an infinite recursion, set reentrant_call to 
+     * is a re-entrant call via a client callback called in the resize
+     * process.  To avoid an infinite recursion, set reentrant_call to
      * TRUE, and goto done.
      */
     if(cache_ptr->resize_in_progress) {
@@ -5157,7 +5157,7 @@ H5C__flush_invalidate_cache(H5F_t *f, unsigned flags)
         while(entry_ptr) {
             /* Check ring */
             HDassert(entry_ptr->ring == H5C_RING_SB);
-            
+
             /* Advance to next entry in pinned entry list */
             entry_ptr = entry_ptr->next;
         } /* end while */
@@ -5199,7 +5199,7 @@ done:
  *		until either the cache is empty, or the number of pinned
  *		entries stops decreasing on each pass.
  *
- *		If flush dependencies appear in the target ring, the 
+ *		If flush dependencies appear in the target ring, the
  *		function makes repeated passes through the cache flushing
  *		entries in flush dependency order.
  *
@@ -5252,8 +5252,8 @@ H5C_flush_invalidate_ring(H5F_t * f, H5C_ring_t ring, unsigned flags)
     /* The flush procedure here is a bit strange.
      *
      * In the outer while loop we make at least one pass through the
-     * cache, and then repeat until either all the pinned entries in 
-     * the ring unpin themselves, or until the number of pinned entries 
+     * cache, and then repeat until either all the pinned entries in
+     * the ring unpin themselves, or until the number of pinned entries
      * in the ring stops declining.  In this later case, we scream and die.
      *
      * Since the fractal heap can dirty, resize, and/or move entries
@@ -5309,9 +5309,9 @@ H5C_flush_invalidate_ring(H5F_t * f, H5C_ring_t ring, unsigned flags)
 
         /* There is also the possibility that entries will be
          * dirtied, resized, moved, and/or removed from the cache
-         * as the result of calls to the flush callbacks.  We use 
-         * the slist_len_increase and slist_size_increase increase 
-         * fields in struct H5C_t to track these changes for purpose 
+         * as the result of calls to the flush callbacks.  We use
+         * the slist_len_increase and slist_size_increase increase
+         * fields in struct H5C_t to track these changes for purpose
          * of sanity checking.
          *
          * To this end, we must zero these fields before we start
@@ -5326,8 +5326,8 @@ H5C_flush_invalidate_ring(H5F_t * f, H5C_ring_t ring, unsigned flags)
          * This flag is set to TRUE by H5C__flush_single_entry if the slist
          * is modified by a pre_serialize, serialize, or notify callback.
          *
-         * H5C_flush_invalidate_ring() uses this flag to detect any 
-         * modifications to the slist that might corrupt the scan of 
+         * H5C_flush_invalidate_ring() uses this flag to detect any
+         * modifications to the slist that might corrupt the scan of
          * the slist -- and restart the scan in this event.
          */
         cache_ptr->slist_changed = FALSE;
@@ -5357,14 +5357,14 @@ H5C_flush_invalidate_ring(H5F_t * f, H5C_ring_t ring, unsigned flags)
 
             entry_ptr = next_entry_ptr;
 
-            /* It is possible that entries will be dirtied, resized, 
+            /* It is possible that entries will be dirtied, resized,
              * flushed, or removed from the cache via the take ownership
-             * flag as the result of pre_serialize or serialized callbacks. 
-             * 
+             * flag as the result of pre_serialize or serialized callbacks.
+             *
              * This in turn can corrupt the scan through the slist.
              *
-             * We test for slist modifications in the pre_serialize 
-             * and serialize callbacks, and restart the scan of the 
+             * We test for slist modifications in the pre_serialize
+             * and serialize callbacks, and restart the scan of the
              * slist if we find them.  However, best we do some extra
              * sanity checking just in case.
              */
@@ -5497,8 +5497,8 @@ H5C_flush_invalidate_ring(H5F_t * f, H5C_ring_t ring, unsigned flags)
             if((!entry_ptr->flush_me_last || (entry_ptr->flush_me_last && cache_ptr->num_last_entries >= cache_ptr->slist_len))
                     && entry_ptr->flush_dep_nchildren == 0 && entry_ptr->ring == ring) {
                 if(entry_ptr->is_protected) {
-                    /* we have major problems -- but lets flush and 
-                     * destroy everything we can before we flag an 
+                    /* we have major problems -- but lets flush and
+                     * destroy everything we can before we flag an
                      * error.
                      */
                     protected_entries++;
@@ -5506,9 +5506,9 @@ H5C_flush_invalidate_ring(H5F_t * f, H5C_ring_t ring, unsigned flags)
                         HDassert(!(entry_ptr->is_dirty));
                 } /* end if */
                 else if(!(entry_ptr->is_pinned)) {
-                    /* if *entry_ptr is dirty, it is possible 
-                     * that one or more other entries may be 
-                     * either removed from the cache, loaded 
+                    /* if *entry_ptr is dirty, it is possible
+                     * that one or more other entries may be
+                     * either removed from the cache, loaded
                      * into the cache, or moved to a new location
                      * in the file as a side effect of the flush.
                      *
@@ -5517,14 +5517,14 @@ H5C_flush_invalidate_ring(H5F_t * f, H5C_ring_t ring, unsigned flags)
                      * entry, allowing it to be removed also and
                      * invalidating the next_entry_ptr.
                      *
-                     * If either of these happen, and one of the target 
-                     * or proxy entries happens to be the next entry in 
+                     * If either of these happen, and one of the target
+                     * or proxy entries happens to be the next entry in
                      * the hash bucket, we could either find ourselves
                      * either scanning a non-existant entry, scanning
                      * through a different bucket, or skipping an entry.
                      *
-                     * Neither of these are good, so restart the 
-                     * the scan at the head of the hash bucket 
+                     * Neither of these are good, so restart the
+                     * the scan at the head of the hash bucket
                      * after the flush if we detect that the next_entry_ptr
                      * becomes invalid.
                      *
@@ -5538,11 +5538,11 @@ H5C_flush_invalidate_ring(H5F_t * f, H5C_ring_t ring, unsigned flags)
                         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Entry flush destroy failed")
 
                     /* Restart the index list scan if necessary.  Must
-                     * do this if the next entry is evicted, and also if 
+                     * do this if the next entry is evicted, and also if
                      * one or more entries are inserted, loaded, or moved
                      * as these operations can result in part of the scan
                      * being skipped -- which can cause a spurious failure
-                     * if this results in the size of the pinned entry 
+                     * if this results in the size of the pinned entry
                      * failing to decline during the pass.
                      */
                     if((NULL != next_entry_ptr && NULL == cache_ptr->entry_watched_for_removal)
@@ -5585,7 +5585,7 @@ H5C_flush_invalidate_ring(H5F_t * f, H5C_ring_t ring, unsigned flags)
             entry_ptr = entry_ptr->next;
         } /* end while */
 
-       /* Check if the number of pinned entries in the ring is positive, and 
+       /* Check if the number of pinned entries in the ring is positive, and
         * it is not declining.  Scream and die if so.
         */
         if(cur_ring_pel_len > 0 && cur_ring_pel_len >= old_ring_pel_len) {
@@ -5628,16 +5628,16 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5C__flush_ring
  *
- * Purpose:	Flush the entries contained in the specified cache and 
+ * Purpose:	Flush the entries contained in the specified cache and
  *		ring.  All entries in rings outside the specified ring
  *		must have been flushed on entry.
  *
  *		If the cache contains protected entries in the specified
- *		ring, the function will fail, as protected entries cannot 
+ *		ring, the function will fail, as protected entries cannot
  *		be flushed.  However all unprotected entries in the target
  *		ring should be flushed before the function returns failure.
  *
- *		If flush dependencies appear in the target ring, the 
+ *		If flush dependencies appear in the target ring, the
  *		function makes repeated passes through the slist flushing
  *		entries in flush dependency order.
  *
@@ -5703,10 +5703,10 @@ H5C__flush_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
 
     /* Set the cache_ptr->slist_changed to false.
      *
-     * This flag is set to TRUE by H5C__flush_single_entry if the 
+     * This flag is set to TRUE by H5C__flush_single_entry if the
      * slist is modified by a pre_serialize, serialize, or notify callback.
      * H5C_flush_cache uses this flag to detect any modifications
-     * to the slist that might corrupt the scan of the slist -- and 
+     * to the slist that might corrupt the scan of the slist -- and
      * restart the scan in this event.
      */
     cache_ptr->slist_changed = FALSE;
@@ -5726,8 +5726,8 @@ H5C__flush_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
          *
          * To make things more entertaining, with the advent of the
          * fractal heap, the entry serialize callback can cause entries
-         * to be dirtied, resized, and/or moved.  Also, the 
-         * pre_serialize callback can result in an entry being 
+         * to be dirtied, resized, and/or moved.  Also, the
+         * pre_serialize callback can result in an entry being
          * removed from the cache via the take ownership flag.
          *
          * To deal with this, we first make note of the initial
@@ -5778,24 +5778,24 @@ H5C__flush_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
                 HDassert(next_entry_ptr->is_dirty);
                 HDassert(next_entry_ptr->in_slist);
             } /* end if */
-                
+
             entry_ptr = next_entry_ptr;
 
             /* With the advent of the fractal heap, the free space
              * manager, and the version 3 cache, it is possible
-             * that the pre-serialize or serialize callback will 
-             * dirty, resize, or take ownership of other entries 
-             * in the cache.  
+             * that the pre-serialize or serialize callback will
+             * dirty, resize, or take ownership of other entries
+             * in the cache.
              *
              * To deal with this, I have inserted code to detect any
              * change in the skip list not directly under the control
              * of this function.  If such modifications are detected,
-             * we must re-start the scan of the skip list to avoid 
+             * we must re-start the scan of the skip list to avoid
              * the possibility that the target of the next_entry_ptr
              * may have been flushed or deleted from the cache.
              *
              * To verify that all such possibilities have been dealt
-             * with, we do a bit of extra sanity checking on 
+             * with, we do a bit of extra sanity checking on
              * entry_ptr.
              */
             HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
@@ -5825,20 +5825,20 @@ H5C__flush_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
             else
                 next_entry_ptr = NULL;
 
-            if((!flush_marked_entries || entry_ptr->flush_marker) 
+            if((!flush_marked_entries || entry_ptr->flush_marker)
                     && (!entry_ptr->flush_me_last ||
-                        (entry_ptr->flush_me_last 
+                        (entry_ptr->flush_me_last
                             && (cache_ptr->num_last_entries >= cache_ptr->slist_len
-                               || (flush_marked_entries && entry_ptr->flush_marker)))) 
+                               || (flush_marked_entries && entry_ptr->flush_marker))))
                     && (entry_ptr->flush_dep_nchildren == 0
-                        || entry_ptr->flush_dep_ndirty_children == 0) 
+                        || entry_ptr->flush_dep_ndirty_children == 0)
                     && entry_ptr->ring == ring) {
 
                 HDassert(entry_ptr->flush_dep_nunser_children == 0);
 
                 if(entry_ptr->is_protected) {
-                    /* we probably have major problems -- but lets 
-                     * flush everything we can before we decide 
+                    /* we probably have major problems -- but lets
+                     * flush everything we can before we decide
                      * whether to flag an error.
                      */
                     tried_to_flush_protected_entry = TRUE;
@@ -5850,9 +5850,9 @@ H5C__flush_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
 
                     if(cache_ptr->slist_changed) {
                         /* The slist has been modified by something
-                         * other than the simple removal of the 
+                         * other than the simple removal of the
                          * of the flushed entry after the flush.
-                         * 
+                         *
                          * This has the potential to corrupt the
                          * scan through the slist, so restart it.
                          */
@@ -5980,11 +5980,11 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
     else
         write_entry = FALSE;
 
-    /* if we have received close warning, and we have been instructed to 
+    /* if we have received close warning, and we have been instructed to
      * generate a metadata cache image, and we have actually constructed
      * the entry images, set suppress_image_entry_frees to TRUE.
      *
-     * Set suppress_image_entry_writes to TRUE if indicated by the 
+     * Set suppress_image_entry_writes to TRUE if indicated by the
      * image_ctl flags.
      */
     if(cache_ptr->close_warning_received && cache_ptr->image_ctl.generate_image
@@ -6063,11 +6063,11 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
         } /* end if ( ! (entry_ptr->image_up_to_date) ) */
     } /* end if */
 
-    /* Finally, write the image to disk.  
-     * 
-     * Note that if the H5AC__CLASS_SKIP_WRITES flag is set in the 
+    /* Finally, write the image to disk.
+     *
+     * Note that if the H5AC__CLASS_SKIP_WRITES flag is set in the
      * in the entry's type, we silently skip the write.  This
-     * flag should only be used in test code. 
+     * flag should only be used in test code.
      */
     if(write_entry) {
         HDassert(entry_ptr->is_dirty);
@@ -6079,8 +6079,8 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
 
         /* Write the image to disk unless the write is suppressed.
          *
-         * This happens if both suppress_image_entry_writes and 
-         * entry_ptr->include_in_image are TRUE, or if the 
+         * This happens if both suppress_image_entry_writes and
+         * entry_ptr->include_in_image are TRUE, or if the
          * H5AC__CLASS_SKIP_WRITES is set in the entry's type.  This
          * flag should only be used in test code
          */
@@ -6113,7 +6113,7 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
 #endif /* H5_HAVE_PARALLEL */
         } /* end if */
 
-        /* if the entry has a notify callback, notify it that we have 
+        /* if the entry has a notify callback, notify it that we have
          * just flushed the entry.
          */
         if(entry_ptr->type->notify &&
@@ -6125,7 +6125,7 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
      * made if it was appropriate to make them.  Similarly, the entry
      * has been written to disk if desired.
      *
-     * Thus it is now safe to update the cache data structures for the 
+     * Thus it is now safe to update the cache data structures for the
      * flush.
      */
 
@@ -6179,7 +6179,7 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
          *
          * 5) Remove it from the tag list for this object
          *
-         * Finally, if the destroy_entry flag is set, discard the 
+         * Finally, if the destroy_entry flag is set, discard the
          * entry.
          */
         H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr, FAIL)
@@ -6213,7 +6213,7 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
         /* We are either doing a flush or a clear.
          *
          * A clear and a flush are the same from the point of
-         * view of the replacement policy and the slist.  
+         * view of the replacement policy and the slist.
          * Hence no differentiation between them.
          *
          * 					JRM -- 7/7/07
@@ -6223,8 +6223,8 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
 
         H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush)
 
-        /* mark the entry as clean and update the index for 
-         * entry clean.  Also, call the clear callback 
+        /* mark the entry as clean and update the index for
+         * entry clean.  Also, call the clear callback
          * if defined.
          */
         entry_ptr->is_dirty = FALSE;
@@ -6256,8 +6256,8 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
        end before the entry_ptr gets freed */
     entry_addr = entry_ptr->addr;
 
-    /* Internal cache data structures should now be up to date, and 
-     * consistent with the status of the entry.  
+    /* Internal cache data structures should now be up to date, and
+     * consistent with the status of the entry.
      *
      * Now discard the entry if appropriate.
      */
@@ -6266,18 +6266,18 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
         HDassert(0 == entry_ptr->flush_dep_nparents);
 
         /* if both suppress_image_entry_frees and entry_ptr->include_in_image
-         * are true, simply set entry_ptr->image_ptr to NULL, as we have 
+         * are true, simply set entry_ptr->image_ptr to NULL, as we have
          * another pointer to the buffer in an instance of H5C_image_entry_t
          * in cache_ptr->image_entries.
          *
          * Otherwise, free the buffer if it exists.
          */
-        if(suppress_image_entry_frees && entry_ptr->include_in_image) 
+        if(suppress_image_entry_frees && entry_ptr->include_in_image)
             entry_ptr->image_ptr = NULL;
         else if(entry_ptr->image_ptr != NULL)
             entry_ptr->image_ptr = H5MM_xfree(entry_ptr->image_ptr);
 
-        /* If the entry is not a prefetched entry, verify that the flush 
+        /* If the entry is not a prefetched entry, verify that the flush
          * dependency parents addresses array has been transferred.
          *
          * If the entry is prefetched, the free_isr routine will dispose of
@@ -6288,8 +6288,8 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
             HDassert(NULL == entry_ptr->fd_parent_addrs);
         } /* end if */
 
-        /* Check whether we should free the space in the file that 
-         * the entry occupies 
+        /* Check whether we should free the space in the file that
+         * the entry occupies
          */
         if(free_file_space) {
             hsize_t fsf_size;
@@ -6326,14 +6326,14 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
         /* Reset the pointer to the cache the entry is within. -QAK */
         entry_ptr->cache_ptr = NULL;
 
-        /* increment entries_removed_counter and set 
-         * last_entry_removed_ptr.  As we are likely abuut to 
-         * free the entry, recall that last_entry_removed_ptr 
+        /* increment entries_removed_counter and set
+         * last_entry_removed_ptr.  As we are likely abuut to
+         * free the entry, recall that last_entry_removed_ptr
          * must NEVER be dereferenced.
          *
          * Recall that these fields are maintained to allow functions
-         * that perform scans of lists of entries to detect the 
-         * unexpected removal of entries (via expunge, eviction, 
+         * that perform scans of lists of entries to detect the
+         * unexpected removal of entries (via expunge, eviction,
          * or take ownership at present), so that they can re-start
          * their scans if necessary.
          *
@@ -6377,15 +6377,15 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
             HDassert(take_ownership);
 
             /* client is taking ownership of the entry.
-             * set bad magic here too so the cache will choke 
+             * set bad magic here too so the cache will choke
              * unless the entry is re-inserted properly
              */
             entry_ptr->magic = H5C__H5C_CACHE_ENTRY_T_BAD_MAGIC;
         } /* end else */
     } /* if (destroy) */
 
-    /* Check if we have to update the page buffer with cleared entries 
-     * so it doesn't go out of date 
+    /* Check if we have to update the page buffer with cleared entries
+     * so it doesn't go out of date
      */
     if(update_page_buffer) {
         /* Sanity check */
@@ -6402,9 +6402,9 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "log_flush callback failed")
 
 done:
-    HDassert( ( ret_value != SUCCEED ) || ( destroy_entry ) || 
+    HDassert( ( ret_value != SUCCEED ) || ( destroy_entry ) ||
               ( ! entry_ptr->flush_in_progress ) );
-    HDassert( ( ret_value != SUCCEED ) || ( destroy_entry ) || 
+    HDassert( ( ret_value != SUCCEED ) || ( destroy_entry ) ||
               ( take_ownership ) || ( ! entry_ptr->is_dirty ) );
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -6421,7 +6421,7 @@ done:
  *              If exceed, adjust 'len' accordingly.
  *
  *              Verify that 'len' should not exceed eoa when 'actual' is
- *              true i.e. 'len' is the actual length from get_load_size 
+ *              true i.e. 'len' is the actual length from get_load_size
  *              callback with non-null image pointer.
  *              If exceed, return error.
  *
@@ -6442,7 +6442,7 @@ H5C__verify_len_eoa(H5F_t *f, const H5C_class_t *type, haddr_t addr,
 
     FUNC_ENTER_STATIC
 
-    /* if type == H5FD_MEM_GHEAP, H5F_block_read() forces 
+    /* if type == H5FD_MEM_GHEAP, H5F_block_read() forces
      * type to H5FD_MEM_DRAW via its call to H5F__accum_read().
      * Thus we do the same for purposes of computing the EOA
      * for sanity checks.
@@ -6574,7 +6574,7 @@ H5C_load_entry(H5F_t *              f,
         /* Get the # of read attempts */
         max_tries = tries = H5F_GET_READ_ATTEMPTS(f);
 
-        /* 
+        /*
          * This do/while loop performs the following till the metadata checksum
          * is correct or the file's number of allowed read attempts are reached.
          *   --read the metadata
@@ -6874,8 +6874,8 @@ H5C__make_space_in_cache(H5F_t *f, size_t space_needed, hbool_t	write_permitted)
     HDassert(cache_ptr->index_size == (cache_ptr->clean_index_size + cache_ptr->dirty_index_size));
 
     /* check to see if cache_ptr->msic_in_progress is TRUE.  If it, this
-     * is a re-entrant call via a client callback called in the make 
-     * space in cache process.  To avoid an infinite recursion, set 
+     * is a re-entrant call via a client callback called in the make
+     * space in cache process.  To avoid an infinite recursion, set
      * reentrant_call to TRUE, and goto done.
      */
     if(cache_ptr->msic_in_progress) {
@@ -6947,9 +6947,9 @@ H5C__make_space_in_cache(H5F_t *f, size_t space_needed, hbool_t	write_permitted)
                     }
 #endif /* H5C_COLLECT_CACHE_STATS */
 
-		    /* reset entries_removed_counter and 
-                     * last_entry_removed_ptr prior to the call to 
-                     * H5C__flush_single_entry() so that we can spot 
+		    /* reset entries_removed_counter and
+                     * last_entry_removed_ptr prior to the call to
+                     * H5C__flush_single_entry() so that we can spot
                      * unexpected removals of entries from the cache,
                      * and set the restart_scan flag if proceeding
                      * would be likely to cause us to scan an entry
@@ -6966,7 +6966,7 @@ H5C__make_space_in_cache(H5F_t *f, size_t space_needed, hbool_t	write_permitted)
 
                         restart_scan = TRUE;
 
-                } else if ( (cache_ptr->index_size + space_needed) > cache_ptr->max_cache_size 
+                } else if ( (cache_ptr->index_size + space_needed) > cache_ptr->max_cache_size
 #ifdef H5_HAVE_PARALLEL
                             && !(entry_ptr->coll_access)
 #endif /* H5_HAVE_PARALLEL */
@@ -7124,7 +7124,7 @@ H5C__make_space_in_cache(H5F_t *f, size_t space_needed, hbool_t	write_permitted)
 
             prev_ptr = entry_ptr->aux_prev;
 
-            if ( ( !(entry_ptr->prefetched_dirty) ) 
+            if ( ( !(entry_ptr->prefetched_dirty) )
 #ifdef H5_HAVE_PARALLEL
                  && ( ! (entry_ptr->coll_access) )
 #endif /* H5_HAVE_PARALLEL */
@@ -7174,7 +7174,7 @@ done:
  *
  * Changes:
  *
- *		Added code to verify that the LRU contains no pinned 
+ *		Added code to verify that the LRU contains no pinned
  *		entries.                        JRM -- 4/25/14
  *
  *-------------------------------------------------------------------------
@@ -7254,7 +7254,7 @@ H5C_validate_lru_list(H5C_t * cache_ptr)
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 6 failed")
         }
 
-        if ( ( entry_ptr->is_pinned ) || 
+        if ( ( entry_ptr->is_pinned ) ||
              ( entry_ptr->pinned_from_client ) ||
              ( entry_ptr->pinned_from_cache ) ) {
 
@@ -7290,7 +7290,7 @@ done:
  *
  * Function:    H5C_validate_pinned_entry_list
  *
- * Purpose:     Debugging function that scans the pinned entry list for 
+ * Purpose:     Debugging function that scans the pinned entry list for
  *              errors.
  *
  *		If an error is detected, the function generates a
@@ -7422,7 +7422,7 @@ done:
  *
  * Function:    H5C_validate_protected_entry_list
  *
- * Purpose:     Debugging function that scans the protected entry list for 
+ * Purpose:     Debugging function that scans the protected entry list for
  *              errors.
  *
  *		If an error is detected, the function generates a
@@ -7547,11 +7547,11 @@ done:
  *
  * Function:    H5C_entry_in_skip_list
  *
- * Purpose:     Debugging function that scans skip list to see if it 
- *		is in present.  We need this, as it is possible for 
+ * Purpose:     Debugging function that scans skip list to see if it
+ *		is in present.  We need this, as it is possible for
  *		an entry to be in the skip list twice.
  *
- * Return:      FALSE if the entry is not in the skip list, and TRUE 
+ * Return:      FALSE if the entry is not in the skip list, and TRUE
  *		if it is.
  *
  * Programmer:  John Mainzer, 11/1/14
@@ -7617,7 +7617,7 @@ H5C_entry_in_skip_list(H5C_t * cache_ptr, H5C_cache_entry_t *target_ptr)
  */
 herr_t
 H5C__flush_marked_entries(H5F_t * f)
-{ 
+{
     herr_t ret_value = SUCCEED;
 
     FUNC_ENTER_PACKAGE
@@ -7639,7 +7639,7 @@ done:
  * Function:    H5C_cork
  *
  * Purpose:     To cork/uncork/get cork status of an object depending on "action":
- *		H5C__SET_CORK: 
+ *		H5C__SET_CORK:
  *			To cork the object
  *			Return error if the object is already corked
  *		H5C__UNCORK:
@@ -7648,7 +7648,7 @@ done:
  * 		H5C__GET_CORKED:
  *			To retrieve the cork status of an object in
  *			the parameter "corked"
- *		
+ *
  * Return:      Success:        Non-negative
  *              Failure:        Negative
  *
@@ -7658,7 +7658,7 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5C_cork(H5C_t *cache_ptr, haddr_t obj_addr, unsigned action, hbool_t *corked) 
+H5C_cork(H5C_t *cache_ptr, haddr_t obj_addr, unsigned action, hbool_t *corked)
 {
     H5C_tag_info_t *tag_info;	/* Points to a tag info struct */
     herr_t              ret_value = SUCCEED;
@@ -7840,8 +7840,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5C__mark_flush_dep_serialized()
  *
- * Purpose:     Decrement the flush_dep_nunser_children fields of all the 
- *		target entry's flush dependency parents in response to 
+ * Purpose:     Decrement the flush_dep_nunser_children fields of all the
+ *		target entry's flush dependency parents in response to
  *		the target entry becoming serialized.
  *
  * Return:      Non-negative on success/Negative on failure
@@ -7890,7 +7890,7 @@ done:
  * Function:    H5C__mark_flush_dep_unserialized()
  *
  * Purpose:     Increment the flush_dep_nunser_children fields of all the
- *              target entry's flush dependency parents in response to 
+ *              target entry's flush dependency parents in response to
  *              the target entry becoming unserialized.
  *
  * Return:      Non-negative on success/Negative on failure
@@ -7916,7 +7916,7 @@ H5C__mark_flush_dep_unserialized(H5C_cache_entry_t * entry_ptr)
         /* Sanity check */
         HDassert(entry_ptr->flush_dep_parent);
         HDassert(entry_ptr->flush_dep_parent[u]->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-        HDassert(entry_ptr->flush_dep_parent[u]->flush_dep_nunser_children < 
+        HDassert(entry_ptr->flush_dep_parent[u]->flush_dep_nunser_children <
                  entry_ptr->flush_dep_parent[u]->flush_dep_nchildren);
 
         /* increment parents number of usserialized children */
@@ -7976,11 +7976,11 @@ H5C__assert_flush_dep_nocycle(const H5C_cache_entry_t * entry,
 /*-------------------------------------------------------------------------
  * Function:    H5C__serialize_cache
  *
- * Purpose:	Serialize (i.e. construct an on disk image) for all entries 
- *		in the metadata cache including clean entries.  
+ * Purpose:	Serialize (i.e. construct an on disk image) for all entries
+ *		in the metadata cache including clean entries.
  *
  *		Note that flush dependencies and "flush me last" flags
- *		must be observed in the serialization process.  
+ *		must be observed in the serialization process.
  *
  *		Note also that entries may be loaded, flushed, evicted,
  *		expunged, relocated, resized, or removed from the cache
@@ -7988,17 +7988,17 @@ H5C__assert_flush_dep_nocycle(const H5C_cache_entry_t * entry,
  *		a regular flush.
  *
  *		However, we are given that the cache will contain no protected
- *		entries on entry to this routine (although entries may be 
- *		briefly protected and then unprotected during the serialize 
- *		process).  
+ *		entries on entry to this routine (although entries may be
+ *		briefly protected and then unprotected during the serialize
+ *		process).
  *
- *		The objective of this routine is serialize all entries and 
- *		to force all entries into their actual locations on disk.  
+ *		The objective of this routine is serialize all entries and
+ *		to force all entries into their actual locations on disk.
  *
- *		The initial need for this routine is to settle all entries 
- *		in the cache prior to construction of the metadata cache 
+ *		The initial need for this routine is to settle all entries
+ *		in the cache prior to construction of the metadata cache
  *		image so that the size of the cache image can be calculated.
- *		However, I gather that other uses for the routine are 
+ *		However, I gather that other uses for the routine are
  *		under consideration.
  *
  * Return:      Non-negative on success/Negative on failure or if there was
@@ -8069,10 +8069,10 @@ H5C__serialize_cache(H5F_t *f)
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
 #ifndef NDEBUG
-    /* if this is a debug build, set the serialization_count field of 
+    /* if this is a debug build, set the serialization_count field of
      * each entry in the cache to zero before we start the serialization.
      * This allows us to detect the case in which any entry is serialized
-     * more than once (a performance issues), and more importantly, the 
+     * more than once (a performance issues), and more importantly, the
      * case is which any flush depencency parent is serializes more than
      * once (a correctness issue).
      */
@@ -8088,10 +8088,10 @@ H5C__serialize_cache(H5F_t *f)
      } /* end block */
 #endif /* NDEBUG */
 
-    /* set cache_ptr->serialization_in_progress to TRUE, and back 
+    /* set cache_ptr->serialization_in_progress to TRUE, and back
      * to FALSE at the end of the function.  Must maintain this flag
-     * to support H5C_get_serialization_in_progress(), which is in 
-     * turn required to support sanity checking in some cache 
+     * to support H5C_get_serialization_in_progress(), which is in
+     * turn required to support sanity checking in some cache
      * clients.
      */
     HDassert(!cache_ptr->serialization_in_progress);
@@ -8169,16 +8169,16 @@ done:
  *
  *              If the cache contains protected entries in the specified
  *              ring, the function will fail, as protected entries cannot
- *              be serialized.  However all unprotected entries in the 
- *		target ring should be serialized before the function 
+ *              be serialized.  However all unprotected entries in the
+ *		target ring should be serialized before the function
  *		returns failure.
  *
  *              If flush dependencies appear in the target ring, the
  *              function makes repeated passes through the index list
  *		serializing entries in flush dependency order.
  *
- *		All entries outside the H5C_RING_SBE are marked for 
- *		inclusion in the cache image.  Entries in H5C_RING_SBE 
+ *		All entries outside the H5C_RING_SBE are marked for
+ *		inclusion in the cache image.  Entries in H5C_RING_SBE
  *		and below are marked for exclusion from the image.
  *
  * Return:      Non-negative on success/Negative on failure or if there was
@@ -8213,76 +8213,76 @@ H5C__serialize_ring(H5F_t *f, H5C_ring_t ring)
     /* The objective here is to serialize all entries in the cache ring
      * in flush dependency order.
      *
-     * The basic algorithm is to scan the cache index list looking for 
+     * The basic algorithm is to scan the cache index list looking for
      * unserialized entries that are either not in a flush dependency
      * relationship, or which have no unserialized children.  Any such
-     * entry is serialized and its flush dependency parents (if any) are 
+     * entry is serialized and its flush dependency parents (if any) are
      * informed -- allowing them to decrement their userialized child counts.
      *
      * However, this algorithm is complicated by the ability
-     * of client serialization callbacks to perform operations on 
-     * on the cache which can result in the insertion, deletion, 
+     * of client serialization callbacks to perform operations on
+     * on the cache which can result in the insertion, deletion,
      * relocation, resize, dirty, flush, eviction, or removal (via the
      * take ownership flag) of entries.  Changes in the flush dependency
      * structure are also possible.
      *
-     * On the other hand, the algorithm is simplified by the fact that 
-     * we are serializing, not flushing.  Thus, as long as all entries 
+     * On the other hand, the algorithm is simplified by the fact that
+     * we are serializing, not flushing.  Thus, as long as all entries
      * are serialized correctly, it doesn't matter if we have to go back
      * and serialize an entry a second time.
      *
-     * These possible actions result in the following modfications to 
+     * These possible actions result in the following modfications to
      * tha basic algorithm:
      *
-     * 1) In the event of an entry expunge, eviction or removal, we must 
-     *    restart the scan as it is possible that the next entry in our 
+     * 1) In the event of an entry expunge, eviction or removal, we must
+     *    restart the scan as it is possible that the next entry in our
      *    scan is no longer in the cache.  Were we to examine this entry,
      *    we would be accessing deallocated memory.
      *
-     * 2) A resize, dirty, or insertion of an entry may result in the 
-     *    the increment of a flush dependency parent's dirty and/or 
-     *    unserialized child count.  In the context of serializing the 
-     *    the cache, this is a non-issue, as even if we have already 
-     *    serialized the parent, it will be marked dirty and its image 
-     *    marked out of date if appropriate when the child is serialized.  
-     *    
+     * 2) A resize, dirty, or insertion of an entry may result in the
+     *    the increment of a flush dependency parent's dirty and/or
+     *    unserialized child count.  In the context of serializing the
+     *    the cache, this is a non-issue, as even if we have already
+     *    serialized the parent, it will be marked dirty and its image
+     *    marked out of date if appropriate when the child is serialized.
+     *
      *    However, this is a major issue for a flush, as were this to happen
      *    in a flush, it would violate the invariant that the flush dependency
-     *    feature is intended to enforce.  As the metadata cache has no 
-     *    control over the behavior of cache clients, it has no way of 
+     *    feature is intended to enforce.  As the metadata cache has no
+     *    control over the behavior of cache clients, it has no way of
      *    preventing this behaviour.  However, it should detect it if at all
-     *    possible.  
+     *    possible.
      *
      *    Do this by maintaining a count of the number of times each entry is
-     *    serialized during a cache serialization.  If any flush dependency 
+     *    serialized during a cache serialization.  If any flush dependency
      *    parent is serialized more than once, throw an assertion failure.
      *
-     * 3) An entry relocation will typically change the location of the 
-     *    entry in the index list.  This shouldn't cause problems as we 
-     *    will scan the index list until we make a complete pass without 
-     *    finding anything to serialize -- making relocations of either 
+     * 3) An entry relocation will typically change the location of the
+     *    entry in the index list.  This shouldn't cause problems as we
+     *    will scan the index list until we make a complete pass without
+     *    finding anything to serialize -- making relocations of either
      *    the current or next entries irrelevant.
      *
-     *    Note that since a relocation may result in our skipping part of 
+     *    Note that since a relocation may result in our skipping part of
      *    the index list, we must always do at least one more pass through
      *    the index list after an entry relocation.
      *
-     * 4) Changes in the flush dependency structure are possible on 
+     * 4) Changes in the flush dependency structure are possible on
      *    entry insertion, load, expunge, evict, or remove.  Destruction
-     *    of a flush dependency has no effect, as it can only relax the 
+     *    of a flush dependency has no effect, as it can only relax the
      *    flush dependencies.  Creation of a flush dependency can create
-     *    an unserialized child of a flush dependency parent where all 
+     *    an unserialized child of a flush dependency parent where all
      *    flush dependency children were previously serialized.  Should
      *    this child dirty the flush dependency parent when it is serialized,
      *    the parent will be re-serialized.
      *
-     *    Per the discussion of 2) above, this is a non issue for cache 
+     *    Per the discussion of 2) above, this is a non issue for cache
      *    serialization, and a major problem for cache flush.  Using the
-     *    same detection mechanism, throw an assertion failure if this 
-     *    condition appears.  
+     *    same detection mechanism, throw an assertion failure if this
+     *    condition appears.
      *
-     * Observe that either eviction or removal of entries as a result of 
-     * a serialization is not a problem as long as the flush depencency 
+     * Observe that either eviction or removal of entries as a result of
+     * a serialization is not a problem as long as the flush depencency
      * tree does not change beyond the removal of a leaf.
      */
     while(!done) {
@@ -8300,7 +8300,7 @@ H5C__serialize_ring(H5F_t *f, H5C_ring_t ring)
 	    HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
 	    /* Verify that either the entry is already serialized, or
-             * that it is assigned to either the target or an inner 
+             * that it is assigned to either the target or an inner
              * ring.
              */
             HDassert((entry_ptr->ring >= ring) || (entry_ptr->image_up_to_date));
@@ -8367,9 +8367,9 @@ H5C__serialize_ring(H5F_t *f, H5C_ring_t ring)
     cache_ptr->entries_relocated_counter  = 0;
 
     /* At this point, all entries not marked "flush me last" and in
-     * the current ring or outside it should be serialized and have up 
-     * to date images.  Scan the index list again to serialize the 
-     * "flush me last" entries (if they are in the current ring) and to 
+     * the current ring or outside it should be serialized and have up
+     * to date images.  Scan the index list again to serialize the
+     * "flush me last" entries (if they are in the current ring) and to
      * verify that all other entries have up to date images.
      */
     entry_ptr = cache_ptr->il_head;
@@ -8422,7 +8422,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5C__serialize_single_entry
  *
- * Purpose:     Serialize the cache entry pointed to by the entry_ptr 
+ * Purpose:     Serialize the cache entry pointed to by the entry_ptr
  *		parameter.
  *
  * Return:      Non-negative on success/Negative on failure
@@ -8487,12 +8487,12 @@ done:
  * Purpose:     Serialize an entry and generate its image.
  *
  * Note:	This may cause the entry to be re-sized and/or moved in
- *              the cache.  
+ *              the cache.
  *
- *              As we will not update the metadata cache's data structures 
- *              until we we finish the write, we must touch up these 
- *              data structures for size and location changes even if we 
- *              are about to delete the entry from the cache (i.e. on a 
+ *              As we will not update the metadata cache's data structures
+ *              until we we finish the write, we must touch up these
+ *              data structures for size and location changes even if we
+ *              are about to delete the entry from the cache (i.e. on a
  *              flush destroy).
  *
  * Return:      Non-negative on success/Negative on failure
@@ -8528,7 +8528,7 @@ H5C__generate_image(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr)
     old_addr = entry_ptr->addr;
 
     /* Call client's pre-serialize callback, if there's one */
-    if(entry_ptr->type->pre_serialize && 
+    if(entry_ptr->type->pre_serialize &&
             (entry_ptr->type->pre_serialize)(f, (void *)entry_ptr,
                 entry_ptr->addr, entry_ptr->size, &new_addr, &new_len, &serialize_flags) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to pre-serialize entry")
@@ -8596,7 +8596,7 @@ H5C__generate_image(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr)
              */
             H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_len);
 
-            /* As we haven't updated the cache data structures for 
+            /* As we haven't updated the cache data structures for
              * for the flush or flush destroy yet, the entry should
              * be in the slist.  Thus update it for the size change.
              */
@@ -8608,8 +8608,8 @@ H5C__generate_image(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr)
             entry_ptr->size = new_len;
         } /* end if */
 
-        /* If required, udate the entry and the cache data structures 
-         * for a move 
+        /* If required, udate the entry and the cache data structures
+         * for a move
          */
         if(serialize_flags & H5C__SERIALIZE_MOVED_FLAG) {
             /* Update stats and entries relocated counter */
@@ -8641,7 +8641,7 @@ H5C__generate_image(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr)
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
     entry_ptr->image_up_to_date = TRUE;
 
-    /* Propagate the fact that the entry is serialized up the 
+    /* Propagate the fact that the entry is serialized up the
      * flush dependency chain if appropriate.  Since the image must
      * have been out of date for this function to have been called
      * (see assertion on entry), no need to check that -- only check
@@ -8766,8 +8766,8 @@ H5C_remove_entry(void *_entry)
     if(entry == cache->entry_watched_for_removal)
         cache->entry_watched_for_removal = NULL;
 
-    /* Internal cache data structures should now be up to date, and 
-     * consistent with the status of the entry.  
+    /* Internal cache data structures should now be up to date, and
+     * consistent with the status of the entry.
      *
      * Now clean up internal cache fields if appropriate.
      */