[svn-r18460] Description:

	Fold metadata journaling changes into the trunk: mostly tweaky
small stuff, also removed the H5F_t* field from the H5G_entry_t struct.

Tested on:
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (jam) w/PGI compilers, w/default API=1.8.x,
                w/C++ & FORTRAN, w/threadsafe, in debug mode
        Linux/64-amd64 2.6 (amani) w/Intel compilers, w/default API=1.6.x,
                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                in production mode
        Linux/64-ia64 2.4 (tg-login3) w/parallel, w/FORTRAN, in debug mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode

1 files changed, 320 insertions, 350 deletions

diff --git a/src/H5C.c b/src/H5C.c
index 32a4123..5479099 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -95,7 +95,7 @@
  *
  **************************************************************************/
 
-#define H5C_PACKAGE		/*suppress error about including H5Cpkg	  */
+#define H5C_PACKAGE		/*suppress error about including H5Cpkg   */
 #define H5F_PACKAGE		/*suppress error about including H5Fpkg	  */
 
 
@@ -111,7 +111,7 @@
 #include "H5Pprivate.h"         /* Property lists                       */
 #include "H5SLprivate.h"	/* Skip lists				*/
 
-
+
 /*
  * Private file-scope variables.
  */
@@ -119,22 +119,21 @@
 /* Declare a free list to manage the H5C_t struct */
 H5FL_DEFINE_STATIC(H5C_t);
 
+
 /*
  * Private file-scope function declarations:
  */
 
-static herr_t H5C__auto_adjust_cache_size(H5C_t * cache_ptr,
-                                          H5F_t * f,
+static herr_t H5C__auto_adjust_cache_size(H5F_t * f,
                                           hid_t primary_dxpl_id,
                                           hid_t secondary_dxpl_id,
                                           hbool_t write_permitted,
                                           hbool_t * first_flush_ptr);
 
-static herr_t H5C__autoadjust__ageout(H5C_t * cache_ptr,
+static herr_t H5C__autoadjust__ageout(H5F_t * f,
                                       double hit_rate,
                                       enum H5C_resize_status * status_ptr,
                                       size_t * new_max_cache_size_ptr,
-                                      H5F_t * f,
                                       hid_t primary_dxpl_id,
                                       hid_t secondary_dxpl_id,
                                       hbool_t write_permitted,
@@ -145,7 +144,6 @@ static herr_t H5C__autoadjust__ageout__cycle_epoch_marker(H5C_t * cache_ptr);
 static herr_t H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
                                                     hid_t primary_dxpl_id,
                                                     hid_t secondary_dxpl_id,
-                                                    H5C_t * cache_ptr,
                                                     hbool_t write_permitted,
                                                     hbool_t * first_flush_ptr);
 
@@ -159,20 +157,18 @@ static herr_t H5C__flash_increase_cache_size(H5C_t * cache_ptr,
                                              size_t old_entry_size,
                                              size_t new_entry_size);
 
-static herr_t H5C_flush_single_entry(H5F_t *             f,
+static herr_t H5C_flush_single_entry(const H5F_t *       f,
                                      hid_t               primary_dxpl_id,
                                      hid_t               secondary_dxpl_id,
-                                     H5C_t *             cache_ptr,
                                      const H5C_class_t * type_ptr,
                                      haddr_t             addr,
                                      unsigned            flags,
                                      hbool_t *           first_flush_ptr,
                                      hbool_t    del_entry_from_slist_on_destroy);
 
-static herr_t H5C_flush_invalidate_cache(H5F_t *  f,
+static herr_t H5C_flush_invalidate_cache(const H5F_t *  f,
 	                                 hid_t    primary_dxpl_id,
 				         hid_t    secondary_dxpl_id,
-				         H5C_t *  cache_ptr,
 					 unsigned flags);
 
 static void * H5C_load_entry(H5F_t *             f,
@@ -186,7 +182,6 @@ static void * H5C_load_entry(H5F_t *             f,
 static herr_t H5C_make_space_in_cache(H5F_t * f,
                                       hid_t   primary_dxpl_id,
                                       hid_t   secondary_dxpl_id,
-                                      H5C_t * cache_ptr,
                                       size_t  space_needed,
                                       hbool_t write_permitted,
                                       hbool_t * first_flush_ptr);
@@ -461,7 +456,6 @@ H5C_create(size_t		      max_cache_size,
         HDassert( HDstrlen(( type_name_table_ptr)[i]) > 0 );
     }
 
-
     if ( NULL == (cache_ptr = H5FL_CALLOC(H5C_t)) ) {
 
 	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, \
@@ -486,6 +480,7 @@ H5C_create(size_t		      max_cache_size,
     cache_ptr->aux_ptr				= aux_ptr;
 
     cache_ptr->max_type_id			= max_type_id;
+
     cache_ptr->type_name_table_ptr		= type_name_table_ptr;
 
     cache_ptr->max_cache_size			= max_cache_size;
@@ -564,10 +559,9 @@ H5C_create(size_t		      max_cache_size,
     (cache_ptr->resize_ctl).apply_max_increment	= TRUE;
     (cache_ptr->resize_ctl).max_increment	= H5C__DEF_AR_MAX_INCREMENT;
 
-    (cache_ptr->resize_ctl).flash_incr_mode	= H5C_flash_incr__off;
-    (cache_ptr->resize_ctl).flash_multiple	= 1.0;
-    (cache_ptr->resize_ctl).flash_threshold	= 0.25;
-
+    (cache_ptr->resize_ctl).flash_incr_mode     = H5C_flash_incr__off;
+    (cache_ptr->resize_ctl).flash_multiple      = 1.0;
+    (cache_ptr->resize_ctl).flash_threshold     = 0.25;
 
     (cache_ptr->resize_ctl).decr_mode		= H5C_decr__off;
     (cache_ptr->resize_ctl).upper_hr_threshold	= H5C__DEF_AR_UPPER_THRESHHOLD;
@@ -593,8 +587,8 @@ H5C_create(size_t		      max_cache_size,
     {
         (cache_ptr->epoch_marker_active)[i]		 = FALSE;
 #ifndef NDEBUG
-	((cache_ptr->epoch_markers)[i]).magic            =
-		                                  H5C__H5C_CACHE_ENTRY_T_MAGIC;
+        ((cache_ptr->epoch_markers)[i]).magic		 =
+					       H5C__H5C_CACHE_ENTRY_T_MAGIC;
 #endif /* NDEBUG */
         ((cache_ptr->epoch_markers)[i]).addr		 = (haddr_t)i;
         ((cache_ptr->epoch_markers)[i]).type		 = &epoch_marker_class;
@@ -662,7 +656,7 @@ done:
  *		H5C_t in output.
  *
  *		JRM 12/31/07
- *		Updated function to handle flash size increases.
+ *              Updated function to handle flash size increases.
  *
  *-------------------------------------------------------------------------
  */
@@ -714,19 +708,19 @@ H5C_def_auto_resize_rpt_fcn(H5C_t * cache_ptr,
             HDassert( old_max_cache_size < new_max_cache_size );
 
             HDfprintf(stdout,
-                      "%sflash cache resize(%d) -- size threshold = %Zu.\n",
-                      cache_ptr->prefix,
-                      (int)((cache_ptr->resize_ctl).flash_incr_mode),
-                      cache_ptr->flash_size_increase_threshold);
+                    "%sflash cache resize(%d) -- size threshold = %Zu.\n",
+                    cache_ptr->prefix,
+                    (int)((cache_ptr->resize_ctl).flash_incr_mode),
+                    cache_ptr->flash_size_increase_threshold);
 
             HDfprintf(stdout,
-                    "%s	cache size increased from (%Zu/%Zu) to (%Zu/%Zu).\n",
-                    cache_ptr->prefix,
-                    old_max_cache_size,
-                    old_min_clean_size,
-                    new_max_cache_size,
-                    new_min_clean_size);
-            break;
+                  "%s cache size increased from (%Zu/%Zu) to (%Zu/%Zu).\n",
+                   cache_ptr->prefix,
+                   old_max_cache_size,
+                   old_min_clean_size,
+                   new_max_cache_size,
+                   new_min_clean_size);
+                break;
 
         case decrease:
             HDassert( old_max_cache_size > new_max_cache_size );
@@ -872,7 +866,7 @@ H5C_dest(H5F_t * f,
 
     /* Flush and invalidate all cache entries */
     if(H5C_flush_invalidate_cache(f, primary_dxpl_id, secondary_dxpl_id,
-                cache_ptr, H5C__NO_FLAGS_SET) < 0 )
+                H5C__NO_FLAGS_SET) < 0 )
         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush cache")
 
     if(cache_ptr->slist_ptr != NULL) {
@@ -916,7 +910,7 @@ H5C_expunge_entry(H5F_t *             f,
                   haddr_t 	      addr,
                   unsigned 	      flags)
 {
-    H5C_t *	        cache_ptr;
+    H5C_t *		cache_ptr;
     herr_t		result;
     hbool_t		first_flush = TRUE;
     H5C_cache_entry_t *	entry_ptr = NULL;
@@ -977,11 +971,9 @@ H5C_expunge_entry(H5F_t *             f,
     result = H5C_flush_single_entry(f,
                                     primary_dxpl_id,
                                     secondary_dxpl_id,
-                                    cache_ptr,
                                     entry_ptr->type,
                                     entry_ptr->addr,
-                                    H5C__FLUSH_INVALIDATE_FLAG |
-				    H5C__FLUSH_CLEAR_ONLY_FLAG,
+                                    H5C__FLUSH_INVALIDATE_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG,
                                     &first_flush,
                                     TRUE);
 
@@ -1104,10 +1096,7 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5C_flush_cache(H5F_t *  f,
-                hid_t    primary_dxpl_id,
-                hid_t    secondary_dxpl_id,
-                unsigned flags)
+H5C_flush_cache(H5F_t *f, hid_t primary_dxpl_id, hid_t secondary_dxpl_id, unsigned flags)
 {
     H5C_t * cache_ptr = f->shared->cache;
     herr_t              status;
@@ -1134,7 +1123,7 @@ H5C_flush_cache(H5F_t *  f,
 
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
-    HDassert( cache_ptr->skip_file_checks || f );
+    HDassert( cache_ptr->skip_file_checks || f);
     HDassert( cache_ptr->slist_ptr );
 
     ignore_protected = ( (flags & H5C__FLUSH_IGNORE_PROTECTED_FLAG) != 0 );
@@ -1158,7 +1147,6 @@ H5C_flush_cache(H5F_t *  f,
         status = H5C_flush_invalidate_cache(f,
 			                    primary_dxpl_id,
 					    secondary_dxpl_id,
-					    cache_ptr,
 					    flags);
 
         if ( status < 0 ) {
@@ -1311,7 +1299,7 @@ H5C_flush_cache(H5F_t *  f,
                         HDassert( next_entry_ptr->in_slist );
                     } else {
                         next_entry_ptr = NULL;
-                    }
+		    }
 
                     HDassert( entry_ptr != NULL );
                     HDassert( entry_ptr->in_slist );
@@ -1342,7 +1330,6 @@ H5C_flush_cache(H5F_t *  f,
                                 status = H5C_flush_single_entry(f,
                                                                 primary_dxpl_id,
                                                                 secondary_dxpl_id,
-                                                                cache_ptr,
                                                                 NULL,
                                                                 entry_ptr->addr,
                                                                 flags,
@@ -1376,7 +1363,6 @@ H5C_flush_cache(H5F_t *  f,
                                 status = H5C_flush_single_entry(f,
                                                                 primary_dxpl_id,
                                                                 secondary_dxpl_id,
-                                                                cache_ptr,
                                                                 NULL,
                                                                 entry_ptr->addr,
                                                                 flags,
@@ -1456,7 +1442,7 @@ end_of_inner_loop:
         }
 #endif /* H5C_DO_SANITY_CHECKS */
 
-   }
+    }
 
 done:
 
@@ -1522,11 +1508,10 @@ done:
 herr_t
 H5C_flush_to_min_clean(H5F_t * f,
                        hid_t   primary_dxpl_id,
-                       hid_t   secondary_dxpl_id,
-                       H5C_t * cache_ptr)
+                       hid_t   secondary_dxpl_id)
 {
+    H5C_t *            cache_ptr;
     herr_t      	result;
-    herr_t		ret_value = SUCCEED;
     hbool_t		first_flush = TRUE;
     hbool_t		write_permitted;
 #if 0 /* modified code -- commented out for now */
@@ -1537,9 +1522,15 @@ H5C_flush_to_min_clean(H5F_t * f,
     haddr_t	      * flushed_entries_list = NULL;
     H5C_cache_entry_t *	entry_ptr = NULL;
 #endif /* JRM */
+    herr_t		ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI(H5C_flush_to_min_clean, FAIL)
 
+    HDassert( f );
+    HDassert( f->shared );
+
+    cache_ptr = f->shared->cache;
+
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( cache_ptr->skip_file_checks || f );
@@ -1569,7 +1560,6 @@ H5C_flush_to_min_clean(H5F_t * f,
     result = H5C_make_space_in_cache(f,
                                      primary_dxpl_id,
                                      secondary_dxpl_id,
-                                     cache_ptr,
                                      (size_t)0,
                                      write_permitted,
                                      &first_flush);
@@ -1646,15 +1636,6 @@ H5C_flush_to_min_clean(H5F_t * f,
             entry_ptr = entry_ptr->aux_prev;
         }
 
-        if ( ( flushed_entries_count > cache_ptr->slist_len) ||
-             ( flushed_entries_size < space_needed ) ) {
-            HDfprintf(stdout, "flushed_entries_count = %d <= %d = slist_size\n",
-                      (int)flushed_entries_count, (int)(cache_ptr->slist_size));
-            HDfprintf(stdout,
-                      "flushed_entries_size = %d < %d = space_needed.\n",
-                      (int)flushed_entries_size, (int)space_needed);
-        }
-
         HDassert( flushed_entries_count <= cache_ptr->slist_len );
         HDassert( flushed_entries_size >= space_needed );
 
@@ -1715,7 +1696,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 herr_t
 H5C_get_cache_auto_resize_config(const H5C_t * cache_ptr,
                                  H5C_auto_size_ctl_t *config_ptr)
@@ -1766,7 +1746,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 herr_t
 H5C_get_cache_size(H5C_t * cache_ptr,
                    size_t * max_size_ptr,
@@ -1830,7 +1809,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 herr_t
 H5C_get_cache_hit_rate(H5C_t * cache_ptr,
                        double * hit_rate_ptr)
@@ -1897,7 +1875,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 herr_t
 H5C_get_entry_status(const H5F_t *f,
                      haddr_t   addr,
@@ -1925,7 +1902,7 @@ H5C_get_entry_status(const H5F_t *f,
     HDassert( H5F_addr_defined(addr) );
     HDassert( in_cache_ptr != NULL );
 
-    /* this test duplicates tow of the above asserts, but we need an
+    /* this test duplicates two of the above asserts, but we need an
      * invocation of HGOTO_ERROR to keep the compiler happy.
      */
     if ( ( cache_ptr == NULL ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
@@ -1987,23 +1964,22 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5C_get_evictions_enabled()
  *
- * Purpose:	Copy the current value of cache_ptr->evictions_enabled into
- * 		*evictions_enabled_ptr.
+ * Purpose:     Copy the current value of cache_ptr->evictions_enabled into
+ *              *evictions_enabled_ptr.
  *
  * Return:      SUCCEED on success, and FAIL on failure.
  *
  * Programmer:  John Mainzer
- *		7/27/07
+ *              7/27/07
  *
  * Modifications:
  *
- *		None.
+ *              None.
  *
  *-------------------------------------------------------------------------
  */
-
 herr_t
-H5C_get_evictions_enabled(const H5C_t * cache_ptr,
+H5C_get_evictions_enabled(const H5C_t *cache_ptr,
                           hbool_t * evictions_enabled_ptr)
 {
     herr_t ret_value = SUCCEED;      /* Return value */
@@ -2018,7 +1994,7 @@ H5C_get_evictions_enabled(const H5C_t * cache_ptr,
     if ( evictions_enabled_ptr == NULL ) {
 
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-		    "Bad evictions_enabled_ptr on entry.")
+                    "Bad evictions_enabled_ptr on entry.")
     }
 
     *evictions_enabled_ptr = cache_ptr->evictions_enabled;
@@ -2051,7 +2027,6 @@ H5C_get_trace_file_ptr(const H5C_t *cache_ptr, FILE **trace_file_ptr_ptr)
 {
     FUNC_ENTER_NOAPI_NOFUNC(H5C_get_trace_file_ptr)
 
-    /* Sanity checks */
     HDassert(cache_ptr);
     HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
     HDassert(trace_file_ptr_ptr);
@@ -2088,7 +2063,6 @@ H5C_get_trace_file_ptr_from_entry(const H5C_cache_entry_t *entry_ptr,
     HDassert(entry_ptr);
     HDassert(entry_ptr->cache_ptr);
 
-    /* Go get the trace file pointer for the cache */
     H5C_get_trace_file_ptr(entry_ptr->cache_ptr, trace_file_ptr_ptr);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
@@ -2202,7 +2176,6 @@ H5C_get_trace_file_ptr_from_entry(const H5C_cache_entry_t *entry_ptr,
  *
  *-------------------------------------------------------------------------
  */
-
 herr_t
 H5C_insert_entry(H5F_t * 	     f,
                  hid_t		     primary_dxpl_id,
@@ -2284,8 +2257,8 @@ H5C_insert_entry(H5F_t * 	     f,
     entry_ptr->magic = H5C__H5C_CACHE_ENTRY_T_MAGIC;
 #endif /* NDEBUG */
     entry_ptr->cache_ptr = cache_ptr;
-    entry_ptr->addr = addr;
-    entry_ptr->type = type;
+    entry_ptr->addr  = addr;
+    entry_ptr->type  = type;
 
     entry_ptr->is_protected = FALSE;
     entry_ptr->is_read_only = FALSE;
@@ -2430,7 +2403,6 @@ H5C_insert_entry(H5F_t * 	     f,
         result = H5C_make_space_in_cache(f,
                                          primary_dxpl_id,
                                          secondary_dxpl_id,
-                                         cache_ptr,
                                          space_needed,
                                          write_permitted,
                                          &first_flush);
@@ -2537,17 +2509,15 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 #ifdef H5_HAVE_PARALLEL
 herr_t
 H5C_mark_entries_as_clean(H5F_t   * f,
                           hid_t     primary_dxpl_id,
                           hid_t     secondary_dxpl_id,
-                          H5C_t   * cache_ptr,
                           int32_t   ce_array_len,
                           haddr_t * ce_array_ptr)
 {
-    herr_t		ret_value = SUCCEED;      /* Return value */
+    H5C_t *             cache_ptr;
     hbool_t		first_flush = TRUE;
     int			entries_cleared;
     int			entries_examined;
@@ -2562,9 +2532,13 @@ H5C_mark_entries_as_clean(H5F_t   * f,
 #endif /* H5C_DO_SANITY_CHECKS */
     H5C_cache_entry_t *	clear_ptr = NULL;
     H5C_cache_entry_t *	entry_ptr = NULL;
+    herr_t		ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI(H5C_mark_entries_as_clean, FAIL)
 
+    HDassert( f );
+    HDassert( f->shared );
+    cache_ptr = f->shared->cache;
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( cache_ptr->skip_file_checks || f );
@@ -2647,7 +2621,6 @@ H5C_mark_entries_as_clean(H5F_t   * f,
             if ( H5C_flush_single_entry(f,
                                         primary_dxpl_id,
                                         secondary_dxpl_id,
-                                        cache_ptr,
                                         entry_ptr->type,
                                         addr,
                                         H5C__FLUSH_CLEAR_ONLY_FLAG,
@@ -2707,7 +2680,6 @@ H5C_mark_entries_as_clean(H5F_t   * f,
             if ( H5C_flush_single_entry(f,
                                         primary_dxpl_id,
                                         secondary_dxpl_id,
-                                        cache_ptr,
                                         clear_ptr->type,
                                         clear_ptr->addr,
                                         H5C__FLUSH_CLEAR_ONLY_FLAG,
@@ -2745,7 +2717,6 @@ H5C_mark_entries_as_clean(H5F_t   * f,
             if ( H5C_flush_single_entry(f,
                                         primary_dxpl_id,
                                         secondary_dxpl_id,
-                                        cache_ptr,
                                         clear_ptr->type,
                                         clear_ptr->addr,
                                         H5C__FLUSH_CLEAR_ONLY_FLAG,
@@ -2867,7 +2838,7 @@ H5C_mark_pinned_entry_dirty(void *thing, hbool_t size_changed, size_t new_size)
             }
         }
 
-        /* update the protected entry list */
+        /* update the pinned entry list */
         H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr->pel_len), \
                                         (cache_ptr->pel_size), \
                                         (entry_ptr->size), (new_size));
@@ -2981,8 +2952,8 @@ H5C_mark_pinned_or_protected_entry_dirty(void *thing)
 
     } else {
 
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, \
-                        "Entry is neither pinned nor protected??")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, \
+                    "Entry is neither pinned nor protected??")
     }
 
 done:
@@ -3020,7 +2991,7 @@ done:
  *		Updated function to support renaming of pinned entries.
  *
  *		JRM -- 8/24/06
- *		Updated function to refrain from alterning the index, the
+ *		Updated function to refrain from altering the index, the
  *		replacement policy data structures, and skip list when
  *              the function is called within the flush callback for the
  *              target entry and the target entry is being destroyed.
@@ -3035,20 +3006,19 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 herr_t
 H5C_rename_entry(H5C_t *	     cache_ptr,
                  const H5C_class_t * type,
                  haddr_t 	     old_addr,
 	         haddr_t 	     new_addr)
 {
-    herr_t		ret_value = SUCCEED;      /* Return value */
-    hbool_t		was_dirty;
+    hbool_t			was_dirty;
     H5C_cache_entry_t *	entry_ptr = NULL;
     H5C_cache_entry_t *	test_entry_ptr = NULL;
 #if H5C_DO_SANITY_CHECKS
-    hbool_t		removed_entry_from_slist = FALSE;
+    hbool_t			removed_entry_from_slist = FALSE;
 #endif /* H5C_DO_SANITY_CHECKS */
+    herr_t			ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI(H5C_rename_entry, FAIL)
 
@@ -3213,7 +3183,7 @@ H5C_resize_pinned_entry(void *thing, size_t new_size)
 {
     H5C_t             * cache_ptr;
     H5C_cache_entry_t * entry_ptr = (H5C_cache_entry_t *)thing;
-    size_t 		size_increase;
+    size_t             	size_increase;
     hbool_t		was_clean;
     herr_t              ret_value = SUCCEED;    /* Return value */
 
@@ -3252,13 +3222,8 @@ H5C_resize_pinned_entry(void *thing, size_t new_size)
 
                 size_increase = new_size - entry_ptr->size;
 
-                if ( size_increase >=
-		     cache_ptr->flash_size_increase_threshold ) {
-
-
-                    if(H5C__flash_increase_cache_size(cache_ptr,
-                                                            entry_ptr->size,
-                                                            new_size) < 0)
+                if(size_increase >= cache_ptr->flash_size_increase_threshold) {
+                    if(H5C__flash_increase_cache_size(cache_ptr, entry_ptr->size, new_size) < 0)
                         HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "flash cache increase failed")
                 }
             }
@@ -3440,9 +3405,9 @@ done:
  *		make space in the cache.
  *
  *		JRM -- 11/12/04
- *		Added code to call to H5C_make_space_in_cache()	after the
- *		call to H5C__auto_adjust_cache_size() if that function
- *		sets the size_decreased flag is TRUE.
+ *		Added code to call to H5C_make_space_in_cache()
+ *		after the call to H5C__auto_adjust_cache_size() if that
+ *		function sets the size_decreased flag is TRUE.
  *
  *		JRM -- 4/25/05
  *		The size_decreased flag can also be set to TRUE in
@@ -3499,7 +3464,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 void *
 H5C_protect(H5F_t *	        f,
             hid_t	        primary_dxpl_id,
@@ -3510,8 +3474,7 @@ H5C_protect(H5F_t *	        f,
             void *	        udata2,
 	    unsigned		flags)
 {
-    /* const char *	fcn_name = "H5C_protect()"; */
-    H5C_t *	        cache_ptr;
+    H5C_t *		cache_ptr;
     hbool_t		hit;
     hbool_t		first_flush;
     hbool_t		have_write_permitted = FALSE;
@@ -3528,7 +3491,9 @@ H5C_protect(H5F_t *	        f,
     /* check args */
     HDassert( f );
     HDassert( f->shared );
+
     cache_ptr = f->shared->cache;
+
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( cache_ptr->skip_file_checks || f );
@@ -3561,9 +3526,11 @@ H5C_protect(H5F_t *	        f,
             HGOTO_ERROR(H5E_CACHE, H5E_BADTYPE, NULL, "incorrect cache entry type")
 
         hit = TRUE;
-        thing = (void *)entry_ptr;
+	thing = (void *)entry_ptr;
+
+    } else {
 
-    } else { /* must try to load the entry from disk. */
+        /* must try to load the entry from disk. */
 
         hit = FALSE;
 
@@ -3577,20 +3544,20 @@ H5C_protect(H5F_t *	        f,
 
         entry_ptr = (H5C_cache_entry_t *)thing;
 
-	/* If the entry is very large, and we are configured to allow it,
-	 * we may wish to perform a flash cache size increase.
-	 */
+        /* If the entry is very large, and we are configured to allow it,
+         * we may wish to perform a flash cache size increase.
+         */
         if ( ( cache_ptr->flash_size_increase_possible ) &&
              ( entry_ptr->size > cache_ptr->flash_size_increase_threshold ) ) {
 
             result = H5C__flash_increase_cache_size(cache_ptr, 0,
-			                            entry_ptr->size);
+                                                     entry_ptr->size);
 
             if ( result < 0 ) {
 
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, \
                             "H5C__flash_increase_cache_size failed.")
-            }
+             }
         }
 
         if ( cache_ptr->index_size >= cache_ptr->max_cache_size ) {
@@ -3608,16 +3575,12 @@ H5C_protect(H5F_t *	        f,
 	 * regardless if the min_free_space requirement is not met.
 	 */
 
-        if ( ( cache_ptr->evictions_enabled )
-	     &&
+        if ( ( cache_ptr->evictions_enabled ) &&
              ( ( (cache_ptr->index_size + entry_ptr->size) >
-	         cache_ptr->max_cache_size
-	       )
+	         cache_ptr->max_cache_size)
 	       ||
-	       (
-	         ( ( empty_space + cache_ptr->clean_index_size ) <
-	           cache_ptr->min_clean_size )
-	       )
+	       ( ( empty_space + cache_ptr->clean_index_size ) <
+	         cache_ptr->min_clean_size )
 	     )
            ) {
 
@@ -3679,18 +3642,22 @@ H5C_protect(H5F_t *	        f,
              *
              * Second, when writes are not permitted it is also possible
              * for the cache to grow without bound.
+	     *
+	     * Third, the user may choose to disable evictions -- causing
+	     * the cache to grow without bound until evictions are
+	     * re-enabled.
              *
              * Finally, we usually don't check to see if the cache is
              * oversized at the end of an unprotect.  As a result, it is
              * possible to have a vastly oversized cache with no protected
              * entries as long as all the protects preceed the unprotects.
              *
-             * Since items 1 and 2 are not changing any time soon, I see
-             * no point in worrying about the third.
+             * Since items 1, 2, and 3 are not changing any time soon, I
+             * see no point in worrying about the fourth.
              */
 
             result = H5C_make_space_in_cache(f, primary_dxpl_id,
-                                             secondary_dxpl_id, cache_ptr,
+                                             secondary_dxpl_id,
                                              space_needed, write_permitted,
                                              &first_flush);
 
@@ -3767,7 +3734,7 @@ H5C_protect(H5F_t *	        f,
     ret_value = thing;
 
     if ( ( cache_ptr->evictions_enabled ) &&
-	 ( ( cache_ptr->size_decreased ) ||
+         ( ( cache_ptr->size_decreased ) ||
            ( ( cache_ptr->resize_enabled ) &&
              ( cache_ptr->cache_accesses >=
                (cache_ptr->resize_ctl).epoch_length ) ) ) ) {
@@ -3805,8 +3772,7 @@ H5C_protect(H5F_t *	        f,
              ( cache_ptr->cache_accesses >=
                (cache_ptr->resize_ctl).epoch_length ) ) {
 
-            result = H5C__auto_adjust_cache_size(cache_ptr,
-                                                 f,
+            result = H5C__auto_adjust_cache_size(f,
                                                  primary_dxpl_id,
                                                  secondary_dxpl_id,
                                                  write_permitted,
@@ -3852,7 +3818,7 @@ H5C_protect(H5F_t *	        f,
 		}
 
                 result = H5C_make_space_in_cache(f, primary_dxpl_id,
-                                                 secondary_dxpl_id, cache_ptr,
+                                                 secondary_dxpl_id,
                                                  (size_t)0, write_permitted,
                                                  &first_flush);
 
@@ -3870,7 +3836,6 @@ done:
 #if H5C_DO_EXTREME_SANITY_CHECKS
         if ( H5C_validate_lru_list(cache_ptr) < 0 ) {
 
-                HDassert(0);
                 HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, \
                             "LRU sanity check failed.\n");
         }
@@ -3949,12 +3914,11 @@ done:
  *		in cache size.
  *
  *		JRM -- 12/31/07
- *		Added code supporting the new flash cache size increase
- *		code.
+ *              Added code supporting the new flash cache size increase
+ *              code.
  *
  *-------------------------------------------------------------------------
  */
-
 herr_t
 H5C_set_cache_auto_resize_config(H5C_t *cache_ptr,
                                  H5C_auto_size_ctl_t *config_ptr)
@@ -4087,7 +4051,7 @@ H5C_set_cache_auto_resize_config(H5C_t *cache_ptr,
     if ( config_ptr->max_size == config_ptr->min_size ) {
 
         cache_ptr->size_increase_possible = FALSE;
-        cache_ptr->flash_size_increase_possible = FALSE;
+	cache_ptr->flash_size_increase_possible = FALSE;
         cache_ptr->size_decrease_possible = FALSE;
     }
 
@@ -4195,7 +4159,7 @@ H5C_set_cache_auto_resize_config(H5C_t *cache_ptr,
         {
             case H5C_flash_incr__off:
                 cache_ptr->flash_size_increase_possible = FALSE;
-	        break;
+                break;
 
             case H5C_flash_incr__add_space:
                 cache_ptr->flash_size_increase_possible = TRUE;
@@ -4206,9 +4170,9 @@ H5C_set_cache_auto_resize_config(H5C_t *cache_ptr,
                 break;
 
             default: /* should be unreachable */
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                            "Unknown flash_incr_mode?!?!?.")
-                break;
+                 HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                             "Unknown flash_incr_mode?!?!?.")
+                 break;
         }
     }
 
@@ -4222,21 +4186,20 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5C_set_evictions_enabled()
  *
- * Purpose:	Set cache_ptr->evictions_enabled to the value of the
- * 		evictions enabled parameter.
+ * Purpose:     Set cache_ptr->evictions_enabled to the value of the
+ *              evictions enabled parameter.
  *
  * Return:      SUCCEED on success, and FAIL on failure.
  *
  * Programmer:  John Mainzer
- *		7/27/07
+ *              7/27/07
  *
  * Modifications:
  *
- *		None.
+ *              None.
  *
  *-------------------------------------------------------------------------
  */
-
 herr_t
 H5C_set_evictions_enabled(H5C_t *cache_ptr,
                           hbool_t evictions_enabled)
@@ -4253,7 +4216,7 @@ H5C_set_evictions_enabled(H5C_t *cache_ptr,
     if ( ( evictions_enabled != TRUE ) && ( evictions_enabled != FALSE ) ) {
 
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-		    "Bad evictions_enabled on entry.")
+                    "Bad evictions_enabled on entry.")
     }
 
     /* There is no fundamental reason why we should not permit
@@ -4267,7 +4230,7 @@ H5C_set_evictions_enabled(H5C_t *cache_ptr,
 	   ( cache_ptr->resize_ctl.decr_mode != H5C_decr__off ) ) ) {
 
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-		    "Can't disable evictions when auto resize enabled.")
+                    "Can't disable evictions when auto resize enabled.")
     }
 
     cache_ptr->evictions_enabled = evictions_enabled;
@@ -4680,11 +4643,11 @@ H5C_stats(H5C_t * cache_ptr,
               hit_rate);
 
     HDfprintf(stdout,
-              "%s  Total write / read (max) protects  = %ld / %ld (%d)\n",
+              "%s  Total write / read (max) protects  = %ld / %ld (%ld)\n",
               cache_ptr->prefix,
               (long)total_write_protects,
               (long)total_read_protects,
-              max_read_protects);
+              (long)max_read_protects);
 
     HDfprintf(stdout,
               "%s  Total clears / flushes / evictions = %ld / %ld / %ld\n",
@@ -5102,10 +5065,10 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5C_unpin_entry(void *thing)
+H5C_unpin_entry(void *_entry_ptr)
 {
     H5C_t             * cache_ptr;
-    H5C_cache_entry_t * entry_ptr = (H5C_cache_entry_t *)thing; /* Pointer to entry to unpin */
+    H5C_cache_entry_t * entry_ptr = (H5C_cache_entry_t *)_entry_ptr; /* Pointer to entry to unpin */
     herr_t              ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(H5C_unpin_entry, FAIL)
@@ -5264,11 +5227,11 @@ H5C_unprotect(H5F_t *		  f,
 #ifdef H5_HAVE_PARALLEL
     hbool_t		clear_entry = FALSE;
 #endif /* H5_HAVE_PARALLEL */
-    herr_t              ret_value = SUCCEED;    /* Return value */
     herr_t              result;
-    size_t		size_increase = 0;
+    size_t              size_increase = 0;
     H5C_cache_entry_t *	entry_ptr;
     H5C_cache_entry_t *	test_entry_ptr;
+    herr_t              ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(H5C_unprotect, FAIL)
 
@@ -5434,7 +5397,7 @@ H5C_unprotect(H5F_t *		  f,
                         if ( result < 0 ) {
 
                             HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
-                                        "H5C__flash_increase_cache_size failed.")
+                                     "H5C__flash_increase_cache_size failed.")
                         }
                     }
                 }
@@ -5557,7 +5520,6 @@ H5C_unprotect(H5F_t *		  f,
             if ( H5C_flush_single_entry(f,
                                         primary_dxpl_id,
                                         secondary_dxpl_id,
-                                        cache_ptr,
                                         type,
                                         addr,
                                         flush_flags,
@@ -5595,7 +5557,6 @@ H5C_unprotect(H5F_t *		  f,
             if ( H5C_flush_single_entry(f,
                                         primary_dxpl_id,
                                         secondary_dxpl_id,
-                                        cache_ptr,
                                         type,
                                         addr,
                                         H5C__FLUSH_CLEAR_ONLY_FLAG,
@@ -5643,7 +5604,7 @@ done:
  *
  *		Added validation for the flash increment fields.
  *
- *						JRM -- 12/31/07
+ *                                              JRM -- 12/31/07
  *
  *-------------------------------------------------------------------------
  */
@@ -5745,7 +5706,7 @@ H5C_validate_resize_config(H5C_auto_size_ctl_t * config_ptr,
                  ( config_ptr->apply_max_increment != FALSE ) ) {
 
                 HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                          "apply_max_increment must be either TRUE or FALSE");
+                            "apply_max_increment must be either TRUE or FALSE");
             }
 
             /* no need to check max_increment, as it is a size_t,
@@ -5755,11 +5716,11 @@ H5C_validate_resize_config(H5C_auto_size_ctl_t * config_ptr,
 
         switch ( config_ptr->flash_incr_mode )
         {
-	    case H5C_flash_incr__off:
+            case H5C_flash_incr__off:
                 /* nothing to do here */
-		break;
+                break;
 
-	    case H5C_flash_incr__add_space:
+            case H5C_flash_incr__add_space:
                 if ( ( config_ptr->flash_multiple < 0.1 ) ||
                      ( config_ptr->flash_multiple > 10.0 ) ) {
 
@@ -5771,15 +5732,15 @@ H5C_validate_resize_config(H5C_auto_size_ctl_t * config_ptr,
                      ( config_ptr->flash_threshold > 1.0 ) ) {
 
                     HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                        "flash_threshold must be in the range [0.1, 1.0]");
+                           "flash_threshold must be in the range [0.1, 1.0]");
                 }
-		break;
+                break;
 
-	    default:
+            default:
                 HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-			    "Invalid flash_incr_mode");
-		break;
-	}
+                            "Invalid flash_incr_mode");
+                break;
+        }
     } /* H5C_RESIZE_CFG__VALIDATE_INCREMENT */
 
 
@@ -6266,20 +6227,18 @@ done:
  *		H5C_auto_size_ctl_t structure.
  *
  *		JRM -- 1/5/08
- *		Added support for flash cache size increases.
+ *              Added support for flash cache size increases.
  *
  *-------------------------------------------------------------------------
  */
-
 static herr_t
-H5C__auto_adjust_cache_size(H5C_t * cache_ptr,
-                            H5F_t * f,
+H5C__auto_adjust_cache_size(H5F_t * f,
                             hid_t primary_dxpl_id,
                             hid_t secondary_dxpl_id,
                             hbool_t write_permitted,
                             hbool_t * first_flush_ptr)
 {
-    herr_t			ret_value = SUCCEED;      /* Return value */
+    H5C_t *			cache_ptr = f->shared->cache;
     herr_t			result;
     hbool_t			inserted_epoch_marker = FALSE;
     size_t			new_max_cache_size = 0;
@@ -6288,9 +6247,11 @@ H5C__auto_adjust_cache_size(H5C_t * cache_ptr,
     size_t			old_min_clean_size = 0;
     double			hit_rate;
     enum H5C_resize_status	status = in_spec; /* will change if needed */
+    herr_t			ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5C__auto_adjust_cache_size)
 
+    HDassert( f );
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( cache_ptr->cache_accesses >=
@@ -6475,11 +6436,10 @@ H5C__auto_adjust_cache_size(H5C_t * cache_ptr,
 
                     } else {
 
-                        result = H5C__autoadjust__ageout(cache_ptr,
+                        result = H5C__autoadjust__ageout(f,
                                                          hit_rate,
                                                          &status,
                                                          &new_max_cache_size,
-                                                         f,
                                                          primary_dxpl_id,
                                                          secondary_dxpl_id,
                                                          write_permitted,
@@ -6552,14 +6512,15 @@ H5C__auto_adjust_cache_size(H5C_t * cache_ptr,
             cache_ptr->size_decreased = TRUE;
         }
 
-        /* update flash cache size increase fields as appropriate */
-        if ( cache_ptr->flash_size_increase_possible ) {
+	/* update flash cache size increase fields as appropriate */
+	if ( cache_ptr->flash_size_increase_possible ) {
 
             switch ( (cache_ptr->resize_ctl).flash_incr_mode )
             {
                 case H5C_flash_incr__off:
+
                     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                       "flash_size_increase_possible but H5C_flash_incr__off?!")
+                     "flash_size_increase_possible but H5C_flash_incr__off?!")
                     break;
 
                 case H5C_flash_incr__add_space:
@@ -6567,7 +6528,7 @@ H5C__auto_adjust_cache_size(H5C_t * cache_ptr,
                         (size_t)
                         (((double)(cache_ptr->max_cache_size)) *
                          ((cache_ptr->resize_ctl).flash_threshold));
-                    break;
+                     break;
 
                 default: /* should be unreachable */
                     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
@@ -6627,24 +6588,24 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 static herr_t
-H5C__autoadjust__ageout(H5C_t * cache_ptr,
+H5C__autoadjust__ageout(H5F_t * f,
                         double hit_rate,
                         enum H5C_resize_status * status_ptr,
                         size_t * new_max_cache_size_ptr,
-                        H5F_t * f,
                         hid_t primary_dxpl_id,
                         hid_t secondary_dxpl_id,
                         hbool_t write_permitted,
                         hbool_t * first_flush_ptr)
 {
-    herr_t	ret_value = SUCCEED;      /* Return value */
+    H5C_t *     cache_ptr = f->shared->cache;
     herr_t	result;
     size_t	test_size;
+    herr_t	ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5C__autoadjust__ageout)
 
+    HDassert( f );
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( ( status_ptr ) && ( *status_ptr == in_spec ) );
@@ -6676,21 +6637,9 @@ H5C__autoadjust__ageout(H5C_t * cache_ptr,
         if ( cache_ptr->max_cache_size > (cache_ptr->resize_ctl).min_size ){
 
             /* evict aged out cache entries if appropriate... */
-            result = H5C__autoadjust__ageout__evict_aged_out_entries
-                     (
-                       f,
-                       primary_dxpl_id,
-                       secondary_dxpl_id,
-                       cache_ptr,
-                       write_permitted,
-                       first_flush_ptr
-                     );
-
-            if ( result != SUCCEED ) {
-
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                            "error flushing aged out entries.")
-            }
+            if(H5C__autoadjust__ageout__evict_aged_out_entries(f, primary_dxpl_id,
+                    secondary_dxpl_id, write_permitted, first_flush_ptr) < 0)
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "error flushing aged out entries.")
 
             /* ... and then reduce cache size if appropriate */
             if ( cache_ptr->index_size < cache_ptr->max_cache_size ) {
@@ -6910,26 +6859,26 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 static herr_t
 H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
                                                 hid_t   primary_dxpl_id,
                                                 hid_t   secondary_dxpl_id,
-                                                H5C_t * cache_ptr,
                                                 hbool_t write_permitted,
                                                 hbool_t * first_flush_ptr)
 {
-    herr_t              ret_value = SUCCEED;      /* Return value */
+    H5C_t *		cache_ptr = f->shared->cache;
     herr_t              result;
     size_t		eviction_size_limit;
     size_t		bytes_evicted = 0;
-    hbool_t             prev_is_dirty = FALSE;
+    hbool_t		prev_is_dirty = FALSE;
     H5C_cache_entry_t * entry_ptr;
     H5C_cache_entry_t * next_ptr;
     H5C_cache_entry_t * prev_ptr;
+    herr_t              ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5C__autoadjust__ageout__evict_aged_out_entries)
 
+    HDassert( f );
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
 
@@ -6971,7 +6920,6 @@ H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
                 result = H5C_flush_single_entry(f,
                                                 primary_dxpl_id,
                                                 secondary_dxpl_id,
-                                                cache_ptr,
                                                 entry_ptr->type,
                                                 entry_ptr->addr,
                                                 H5C__NO_FLAGS_SET,
@@ -6984,7 +6932,6 @@ H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
                 result = H5C_flush_single_entry(f,
                                                 primary_dxpl_id,
                                                 secondary_dxpl_id,
-                                                cache_ptr,
                                                 entry_ptr->type,
                                                 entry_ptr->addr,
                                                 H5C__FLUSH_INVALIDATE_FLAG,
@@ -7002,24 +6949,24 @@ H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
 #ifndef NDEBUG
                 if ( prev_ptr->magic != H5C__H5C_CACHE_ENTRY_T_MAGIC ) {
 
-                   /* something horrible has happened to *prev_ptr --
-                    * scream and die.
-                    */
-                   HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                               "*prev_ptr corrupt")
+                    /* something horrible has happened to *prev_ptr --
+                     * scream and die.
+                     */
+                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+                                "*prev_ptr corrupt")
 
                 } else
 #endif /* NDEBUG */
 		if ( ( prev_ptr->is_dirty != prev_is_dirty )
-                            ||
-                            ( prev_ptr->next != next_ptr )
-                            ||
-                            ( prev_ptr->is_protected )
-                            ||
-                            ( prev_ptr->is_pinned ) ) {
+                         ||
+                         ( prev_ptr->next != next_ptr )
+                         ||
+                         ( prev_ptr->is_protected )
+                         ||
+                         ( prev_ptr->is_pinned ) ) {
 
                     /* something has happened to the LRU -- start over
-                     * from the tail.
+		     * from the tail.
                      */
                     entry_ptr = cache_ptr->LRU_tail_ptr;
 
@@ -7028,11 +6975,11 @@ H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
                     entry_ptr = prev_ptr;
 
                 }
-            } else {
+	    } else {
 
-                entry_ptr = NULL;
+		entry_ptr = NULL;
 
-            }
+	    }
         } /* end while */
 
         /* for now at least, don't bother to maintain the minimum clean size,
@@ -7083,7 +7030,6 @@ H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
                 result = H5C_flush_single_entry(f,
                                                 primary_dxpl_id,
                                                 secondary_dxpl_id,
-                                                cache_ptr,
                                                 entry_ptr->type,
                                                 entry_ptr->addr,
                                                 H5C__FLUSH_INVALIDATE_FLAG,
@@ -7376,12 +7322,13 @@ done:
 
 } /* H5C__autoadjust__ageout__remove_excess_markers() */
 
+
 /*-------------------------------------------------------------------------
  *
- * Function:	H5C__flash_increase_cache_size
+ * Function:    H5C__flash_increase_cache_size
  *
- * Purpose:    	If there is not at least new_entry_size - old_entry_size
- *		bytes of free space in the cache and the current
+ * Purpose:     If there is not at least new_entry_size - old_entry_size
+ *              bytes of free space in the cache and the current
  *              max_cache_size is less than (cache_ptr->resize_ctl).max_size,
  *              perform a flash increase in the cache size and then reset
  *              the full cache hit rate statistics, and exit.
@@ -7392,27 +7339,26 @@ done:
  *
  * Modifications:
  *
- *		None.
+ *              None.
  *
  *-------------------------------------------------------------------------
  */
-
 static herr_t
 H5C__flash_increase_cache_size(H5C_t * cache_ptr,
                                size_t old_entry_size,
                                size_t new_entry_size)
 {
-    /* const char *	fcn_name = "H5C__flash_increase_cache_size()";*/
-    herr_t			ret_value = SUCCEED;      /* Return value */
-    size_t			new_max_cache_size = 0;
-    size_t			old_max_cache_size = 0;
-    size_t			new_min_clean_size = 0;
-    size_t			old_min_clean_size = 0;
-    size_t                      space_needed;
-    enum H5C_resize_status	status = flash_increase; /* may change */
-    double			hit_rate;
+    size_t                     new_max_cache_size = 0;
+    size_t                     old_max_cache_size = 0;
+    size_t                     new_min_clean_size = 0;
+    size_t                     old_min_clean_size = 0;
+    size_t                     space_needed;
+    enum H5C_resize_status     status = flash_increase;  /* may change */
+    double                     hit_rate;
+    herr_t                     ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5C__flash_increase_cache_size)
+
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( cache_ptr->flash_size_increase_possible );
@@ -7428,7 +7374,7 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
     space_needed = new_entry_size - old_entry_size;
 
     if ( ( (cache_ptr->index_size + space_needed) >
-                           cache_ptr->max_cache_size ) &&
+                            cache_ptr->max_cache_size ) &&
          ( cache_ptr->max_cache_size < (cache_ptr->resize_ctl).max_size ) ) {
 
         /* we have work to do */
@@ -7441,15 +7387,16 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
                 break;
 
             case H5C_flash_incr__add_space:
-		if ( cache_ptr->index_size < cache_ptr->max_cache_size ) {
+                if ( cache_ptr->index_size < cache_ptr->max_cache_size ) {
 
-		    HDassert( (cache_ptr->max_cache_size - cache_ptr->index_size)
-				    < space_needed );
-                    space_needed -= cache_ptr->max_cache_size - cache_ptr->index_size;
-		}
-		space_needed =
-		    (size_t)(((double)space_needed) *
-			     (cache_ptr->resize_ctl).flash_multiple);
+                    HDassert( (cache_ptr->max_cache_size - cache_ptr->index_size)
+                               < space_needed );
+                    space_needed -= cache_ptr->max_cache_size -
+			            cache_ptr->index_size;
+                }
+                space_needed =
+                    (size_t)(((double)space_needed) *
+                             (cache_ptr->resize_ctl).flash_multiple);
 
                 new_max_cache_size = cache_ptr->max_cache_size + space_needed;
 
@@ -7463,7 +7410,7 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
 
         if ( new_max_cache_size > (cache_ptr->resize_ctl).max_size ) {
 
-	    new_max_cache_size = (cache_ptr->resize_ctl).max_size;
+            new_max_cache_size = (cache_ptr->resize_ctl).max_size;
         }
 
         HDassert( new_max_cache_size > cache_ptr->max_cache_size );
@@ -7487,7 +7434,7 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
         {
             case H5C_flash_incr__off:
                 HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                   "flash_size_increase_possible but H5C_flash_incr__off?!")
+                    "flash_size_increase_possible but H5C_flash_incr__off?!")
                 break;
 
             case H5C_flash_incr__add_space:
@@ -7504,15 +7451,15 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
         }
 
         /* note that we don't cycle the epoch markers.  We can
-         * argue either way as to whether we should, but for now
-         * we don't.
-         */
+	 * argue either way as to whether we should, but for now
+	 * we don't.
+	 */
 
         if ( (cache_ptr->resize_ctl).rpt_fcn != NULL ) {
 
-	    /* get the hit rate for the reporting function.  Should still
-	     * be good as we havent reset the hit rate statistics.
-	     */
+            /* get the hit rate for the reporting function.  Should still
+             * be good as we havent reset the hit rate statistics.
+             */
             if ( H5C_get_cache_hit_rate(cache_ptr, &hit_rate) != SUCCEED ) {
 
                 HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't get hit rate.")
@@ -7601,19 +7548,18 @@ done:
  *              but one can argue that I should just scream and die if I
  *              ever detect the condidtion.
  *
- * 							-- JRM 10/13/07
+ *                                                      -- JRM 10/13/07
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5C_flush_invalidate_cache(H5F_t *  f,
+static herr_t
+H5C_flush_invalidate_cache(const H5F_t * f,
                            hid_t    primary_dxpl_id,
                            hid_t    secondary_dxpl_id,
-                           H5C_t *  cache_ptr,
 			   unsigned flags)
 {
+    H5C_t *		cache_ptr = f->shared->cache;
     herr_t              status;
-    herr_t		ret_value = SUCCEED;
     hbool_t		first_flush = TRUE;
     int32_t		protected_entries = 0;
     int32_t		i;
@@ -7630,9 +7576,11 @@ H5C_flush_invalidate_cache(H5F_t *  f,
     size_t              actual_slist_size = 0;
     size_t              initial_slist_size = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
+    herr_t		ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI(H5C_flush_invalidate_cache, FAIL)
 
+    HDassert( f );
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( cache_ptr->skip_file_checks || f );
@@ -7727,6 +7675,7 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                 HDassert( next_entry_ptr->in_slist );
             }
 
+
 #if H5C_DO_SANITY_CHECKS
             /* Depending on circumstances, H5C_flush_single_entry() will
              * remove dirty entries from the slist as it flushes them.
@@ -7818,7 +7767,7 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                     HDassert( next_entry_ptr->in_slist );
                 } else {
                     next_entry_ptr = NULL;
-                }
+	        }
 
                 /* Note that we now remove nodes from the slist as we flush
                  * the associated entries, instead of leaving them there
@@ -7867,7 +7816,6 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                         status = H5C_flush_single_entry(f,
                                                         primary_dxpl_id,
                                                         secondary_dxpl_id,
-                                                        cache_ptr,
                                                         NULL,
                                                         entry_ptr->addr,
                                                         H5C__NO_FLAGS_SET,
@@ -7894,11 +7842,9 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                         status = H5C_flush_single_entry(f,
                                                         primary_dxpl_id,
                                                         secondary_dxpl_id,
-                                                        cache_ptr,
                                                         NULL,
                                                         entry_ptr->addr,
-                                                        (cooked_flags |
-                                                         H5C__FLUSH_INVALIDATE_FLAG),
+                                                        (cooked_flags | H5C__FLUSH_INVALIDATE_FLAG),
                                                         &first_flush,
                                                         TRUE);
                         if ( status < 0 ) {
@@ -7955,6 +7901,9 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                 while ( next_entry_ptr != NULL )
                 {
                     entry_ptr = next_entry_ptr;
+#ifndef NDEBUG
+                    HDassert( entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC );
+#endif /* NDEBUG */
 
                     next_entry_ptr = entry_ptr->ht_next;
                     HDassert ( ( next_entry_ptr == NULL ) ||
@@ -7979,11 +7928,9 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                             status = H5C_flush_single_entry(f,
                                                             primary_dxpl_id,
                                                             secondary_dxpl_id,
-                                                            cache_ptr,
                                                             NULL,
                                                             entry_ptr->addr,
-                                                            (cooked_flags |
-                                                            H5C__FLUSH_INVALIDATE_FLAG),
+                                                            (cooked_flags | H5C__FLUSH_INVALIDATE_FLAG),
                                                             &first_flush,
                                                             TRUE);
                             if ( status < 0 ) {
@@ -8213,16 +8160,16 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5C_flush_single_entry(H5F_t *		   f,
+H5C_flush_single_entry(const H5F_t *	   f,
                        hid_t 		   primary_dxpl_id,
                        hid_t 		   secondary_dxpl_id,
-                       H5C_t *		   cache_ptr,
                        const H5C_class_t * type_ptr,
                        haddr_t		   addr,
                        unsigned		   flags,
                        hbool_t *	   first_flush_ptr,
                        hbool_t		   del_entry_from_slist_on_destroy)
 {
+    H5C_t *	     	cache_ptr = f->shared->cache;
     hbool_t		destroy;
     hbool_t		clear_only;
     hbool_t		take_ownership;
@@ -8231,12 +8178,12 @@ H5C_flush_single_entry(H5F_t *		   f,
     herr_t		status;
     int			type_id;
     unsigned		flush_flags = H5C_CALLBACK__NO_FLAGS_SET;
-    H5C_cache_entry_t *	entry_ptr = NULL;
+    H5C_cache_entry_t * entry_ptr = NULL;
     herr_t		ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5C_flush_single_entry)
 
-
+    HDassert( f );
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( cache_ptr->skip_file_checks || f );
@@ -8288,8 +8235,8 @@ H5C_flush_single_entry(H5F_t *		   f,
      */
     else {
         HDfprintf(stdout,
-                  "H5C_flush_single_entry(): non-existant entry. addr = %a\n",
-                  addr);
+               "H5C_flush_single_entry(): non-existant entry. addr = %a\n",
+               addr);
         HDfflush(stdout);
     }
 #endif
@@ -8414,38 +8361,56 @@ H5C_flush_single_entry(H5F_t *		   f,
         if ( destroy ) { /* AKA eviction */
 
 #if 0 /* JRM */
-            /* This test code may come in handy -- lets keep it for a while */
+            /* This test code may come in handy -- lets keep it for a while.
+             *
+             * Note that it will cause spurious errors in the serial case
+             * unless we are maintaining the clean and dirty LRU lists.
+             */
             {
                 if ( entry_ptr->is_dirty )
                 {
                     if ( cache_ptr->dLRU_head_ptr == NULL )
-                        HDfprintf(stdout,"cache_ptr->dLRU_head_ptr == NULL.\n");
+                        HDfprintf(stdout,
+                                  "%s: cache_ptr->dLRU_head_ptr == NULL.\n",
+                                  FUNC);
 
                     if ( cache_ptr->dLRU_tail_ptr == NULL )
-                        HDfprintf(stdout,"cache_ptr->dLRU_tail_ptr == NULL.\n");
+                        HDfprintf(stdout,
+                                  "%s: cache_ptr->dLRU_tail_ptr == NULL.\n",
+                                  FUNC);
 
                     if ( cache_ptr->dLRU_list_len <= 0 )
-                        HDfprintf(stdout,"cache_ptr->dLRU_list_len <= 0.\n");
+                        HDfprintf(stdout,
+                                  "%s: cache_ptr->dLRU_list_len <= 0.\n",
+                                  FUNC);
 
                     if ( cache_ptr->dLRU_list_size <= 0 )
-                        HDfprintf(stdout,"cache_ptr->dLRU_list_size <= 0.\n");
+                        HDfprintf(stdout,
+                                  "%s: cache_ptr->dLRU_list_size <= 0.\n",
+                                  FUNC);
 
                     if ( cache_ptr->dLRU_list_size < entry_ptr->size )
                         HDfprintf(stdout,
-                              "cache_ptr->dLRU_list_size < entry_ptr->size.\n");
+                          "%s: cache_ptr->dLRU_list_size < entry_ptr->size.\n",
+                          FUNC);
 
                     if ( ( (cache_ptr->dLRU_list_size) == entry_ptr->size ) &&
                          ( ! ( (cache_ptr->dLRU_list_len) == 1 ) ) )
                         HDfprintf(stdout,
-                              "dLRU_list_size == size && dLRU_list_len != 1\n");
+                          "%s: dLRU_list_size == size && dLRU_list_len != 1\n",
+                          FUNC);
 
                     if ( ( entry_ptr->aux_prev == NULL ) &&
                          ( cache_ptr->dLRU_head_ptr != entry_ptr ) )
-                        HDfprintf(stdout, "entry_ptr->aux_prev == NULL && dLRU_head_ptr != entry_ptr\n");
+                        HDfprintf(stdout,
+                                  "%s: entry_ptr->aux_prev == NULL && dLRU_head_ptr != entry_ptr\n",
+                                  FUNC);
 
                     if ( ( entry_ptr->aux_next == NULL ) &&
                          ( cache_ptr->dLRU_tail_ptr != entry_ptr ) )
-                        HDfprintf(stdout, "entry_ptr->aux_next == NULL && dLRU_tail_ptr != entry_ptr\n");
+                        HDfprintf(stdout,
+                                  "%s: entry_ptr->aux_next == NULL && dLRU_tail_ptr != entry_ptr\n",
+                                  FUNC);
 
                     if ( ( cache_ptr->dLRU_list_len == 1 ) &&
                          ( ! ( ( cache_ptr->dLRU_head_ptr == entry_ptr ) &&
@@ -8457,40 +8422,52 @@ H5C_flush_single_entry(H5F_t *		   f,
                          )
                        )
                     {
-                        HDfprintf(stdout, "single entry dlru sanity check fails\n");
+                        HDfprintf(stdout,
+                               "%s: single entry dlru sanity check fails\n",
+                               FUNC);
                     }
 
                 }
                 else
                 {
                     if ( cache_ptr->cLRU_head_ptr == NULL )
-                        HDfprintf(stdout,"cache_ptr->cLRU_head_ptr == NULL.\n");
+                        HDfprintf(stdout,
+                                  "%s: cache_ptr->cLRU_head_ptr == NULL.\n",
+                                  FUNC);
 
                     if ( cache_ptr->cLRU_tail_ptr == NULL )
-                        HDfprintf(stdout,"cache_ptr->cLRU_tail_ptr == NULL.\n");
+                        HDfprintf(stdout,
+                                  "%s: cache_ptr->cLRU_tail_ptr == NULL.\n",
+                                   FUNC);
 
                     if ( cache_ptr->cLRU_list_len <= 0 )
-                        HDfprintf(stdout,"cache_ptr->cLRU_list_len <= 0.\n");
+                        HDfprintf(stdout,
+                                  "%s: cache_ptr->cLRU_list_len <= 0.\n",
+                                  FUNC);
 
                     if ( cache_ptr->cLRU_list_size <= 0 )
-                        HDfprintf(stdout,"cache_ptr->cLRU_list_size <= 0.\n");
+                        HDfprintf(stdout,
+                                  "%s: cache_ptr->cLRU_list_size <= 0.\n",
+                                  FUNC);
 
                     if ( cache_ptr->cLRU_list_size < entry_ptr->size )
                         HDfprintf(stdout,
-                              "cache_ptr->cLRU_list_size < entry_ptr->size.\n");
+                          "%s: cache_ptr->cLRU_list_size < entry_ptr->size.\n",
+                          FUNC);
 
                     if ( ( (cache_ptr->cLRU_list_size) == entry_ptr->size ) &&
                          ( ! ( (cache_ptr->cLRU_list_len) == 1 ) ) )
                         HDfprintf(stdout,
-                              "cLRU_list_size == size && cLRU_list_len != 1\n");
+                              "%s: cLRU_list_size == size && cLRU_list_len != 1\n",
+                              FUNC);
 
                     if ( ( entry_ptr->aux_prev == NULL ) &&
                          ( cache_ptr->cLRU_head_ptr != entry_ptr ) )
-                        HDfprintf(stdout, "entry_ptr->aux_prev == NULL && cLRU_head_ptr != entry_ptr\n");
+                        HDfprintf(stdout, "%s: entry_ptr->aux_prev == NULL && cLRU_head_ptr != entry_ptr\n", FUNC);
 
                     if ( ( entry_ptr->aux_next == NULL ) &&
                          ( cache_ptr->cLRU_tail_ptr != entry_ptr ) )
-                        HDfprintf(stdout, "entry_ptr->aux_next == NULL && cLRU_tail_ptr != entry_ptr\n");
+                        HDfprintf(stdout, "%s: entry_ptr->aux_next == NULL && cLRU_tail_ptr != entry_ptr\n", FUNC);
 
                     if ( ( cache_ptr->cLRU_list_len == 1 ) &&
                          ( ! ( ( cache_ptr->cLRU_head_ptr == entry_ptr ) &&
@@ -8502,7 +8479,9 @@ H5C_flush_single_entry(H5F_t *		   f,
                          )
                        )
                     {
-                        HDfprintf(stdout, "single entry clru sanity check fails\n");
+                        HDfprintf(stdout,
+                                  "%s: single entry clru sanity check fails\n",
+                                  FUNC);
                     }
                 }
             }
@@ -8779,7 +8758,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-
 static void *
 H5C_load_entry(H5F_t *             f,
                hid_t               dxpl_id,
@@ -8800,6 +8778,9 @@ H5C_load_entry(H5F_t *             f,
 
     FUNC_ENTER_NOAPI_NOINIT(H5C_load_entry)
 
+    HDassert( f );
+    HDassert( f->shared );
+    HDassert( f->shared->cache );
     HDassert( skip_file_checks || f );
     HDassert( type );
     HDassert( type->load );
@@ -8839,21 +8820,21 @@ H5C_load_entry(H5F_t *             f,
 
     HDassert( ( entry_ptr->is_dirty == FALSE ) || ( type->id == 5 ) );
 #ifndef NDEBUG
-    entry_ptr->magic = H5C__H5C_CACHE_ENTRY_T_MAGIC;
+    entry_ptr->magic                = H5C__H5C_CACHE_ENTRY_T_MAGIC;
 #endif /* NDEBUG */
-    entry_ptr->cache_ptr = f->shared->cache;
-    entry_ptr->addr = addr;
-    entry_ptr->type = type;
-    entry_ptr->is_protected = FALSE;
-    entry_ptr->is_read_only = FALSE;
-    entry_ptr->ro_ref_count = 0;
-    entry_ptr->in_slist = FALSE;
-    entry_ptr->flush_marker = FALSE;
+    entry_ptr->cache_ptr            = f->shared->cache;
+    entry_ptr->addr                 = addr;
+    entry_ptr->type                 = type;
+    entry_ptr->is_protected         = FALSE;
+    entry_ptr->is_read_only         = FALSE;
+    entry_ptr->ro_ref_count         = 0;
+    entry_ptr->in_slist             = FALSE;
+    entry_ptr->flush_marker         = FALSE;
 #ifdef H5_HAVE_PARALLEL
-    entry_ptr->clear_on_unprotect = FALSE;
+    entry_ptr->clear_on_unprotect   = FALSE;
 #endif /* H5_HAVE_PARALLEL */
-    entry_ptr->flush_in_progress = FALSE;
-    entry_ptr->destroy_in_progress = FALSE;
+    entry_ptr->flush_in_progress    = FALSE;
+    entry_ptr->destroy_in_progress  = FALSE;
     entry_ptr->free_file_space_on_destroy = FALSE;
 
     if ( (type->size)(f, thing, &(entry_ptr->size)) < 0 ) {
@@ -8873,11 +8854,11 @@ H5C_load_entry(H5F_t *             f,
     entry_ptr->ht_next = NULL;
     entry_ptr->ht_prev = NULL;
 
-    entry_ptr->next = NULL;
-    entry_ptr->prev = NULL;
+    entry_ptr->next                 = NULL;
+    entry_ptr->prev                 = NULL;
 
-    entry_ptr->aux_next = NULL;
-    entry_ptr->aux_prev = NULL;
+    entry_ptr->aux_next             = NULL;
+    entry_ptr->aux_prev             = NULL;
 
     H5C__RESET_CACHE_ENTRY_STATS(entry_ptr);
 
@@ -8984,17 +8965,15 @@ done:
  *              scanned statistics.
  *-------------------------------------------------------------------------
  */
-
 static herr_t
 H5C_make_space_in_cache(H5F_t *	f,
                         hid_t	primary_dxpl_id,
                         hid_t	secondary_dxpl_id,
-                        H5C_t *	cache_ptr,
 		        size_t	space_needed,
                         hbool_t	write_permitted,
                         hbool_t * first_flush_ptr)
 {
-    herr_t		ret_value = SUCCEED;      /* Return value */
+    H5C_t *		cache_ptr = f->shared->cache;
     herr_t		result;
 #if H5C_COLLECT_CACHE_STATS
     int32_t             clean_entries_skipped = 0;
@@ -9003,14 +8982,16 @@ H5C_make_space_in_cache(H5F_t *	f,
     int32_t		entries_examined = 0;
     int32_t		initial_list_len;
     size_t		empty_space;
-    hbool_t             prev_is_dirty = FALSE;
+    hbool_t		prev_is_dirty = FALSE;
     hbool_t             didnt_flush_entry = FALSE;
     H5C_cache_entry_t *	entry_ptr;
-    H5C_cache_entry_t *	next_ptr;
     H5C_cache_entry_t *	prev_ptr;
+    H5C_cache_entry_t *	next_ptr;
+    herr_t		ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5C_make_space_in_cache)
 
+    HDassert( f );
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( first_flush_ptr != NULL );
@@ -9055,13 +9036,13 @@ H5C_make_space_in_cache(H5F_t *	f,
             HDassert( ! (entry_ptr->is_read_only) );
             HDassert( (entry_ptr->ro_ref_count) == 0 );
 
-            next_ptr = entry_ptr->next;
-	    prev_ptr = entry_ptr->prev;
+	    next_ptr = entry_ptr->next;
+            prev_ptr = entry_ptr->prev;
 
 	    if ( prev_ptr != NULL ) {
 
-                prev_is_dirty = prev_ptr->is_dirty;
-            }
+		prev_is_dirty = prev_ptr->is_dirty;
+	    }
 
             if ( (entry_ptr->type)->id != H5C__EPOCH_MARKER_TYPE ) {
 
@@ -9080,7 +9061,6 @@ H5C_make_space_in_cache(H5F_t *	f,
                     result = H5C_flush_single_entry(f,
                                                     primary_dxpl_id,
                                                     secondary_dxpl_id,
-                                                    cache_ptr,
                                                     entry_ptr->type,
                                                     entry_ptr->addr,
                                                     H5C__NO_FLAGS_SET,
@@ -9096,7 +9076,6 @@ H5C_make_space_in_cache(H5F_t *	f,
                     result = H5C_flush_single_entry(f,
                                                     primary_dxpl_id,
                                                     secondary_dxpl_id,
-                                                    cache_ptr,
                                                     entry_ptr->type,
                                                     entry_ptr->addr,
                                                     H5C__FLUSH_INVALIDATE_FLAG,
@@ -9136,48 +9115,51 @@ H5C_make_space_in_cache(H5F_t *	f,
                             "unable to flush entry")
             }
 
-            if ( prev_ptr != NULL ) {
+	    if ( prev_ptr != NULL ) {
 #ifndef NDEBUG
-                if ( prev_ptr->magic != H5C__H5C_CACHE_ENTRY_T_MAGIC ) {
+		if ( prev_ptr->magic != H5C__H5C_CACHE_ENTRY_T_MAGIC ) {
 
-                    /* something horrible has happened to *prev_ptr --
-                     * scream and die.
-                     */
+		    /* something horrible has happened to *prev_ptr --
+		     * scream and die.
+		     */
                     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                                "*prev_ptr corrupt 1")
+				"*prev_ptr corrupt 1")
 
                 }
 #endif /* NDEBUG */
 		if ( didnt_flush_entry ) {
 
-		    entry_ptr = prev_ptr;
+		    /* epoch markers don't get flushed, so the sanity checks
+		     * on normal entries will fail -- thus just set entry_ptr
+		     * to prev_ptr and go on.
+		     */
+                    entry_ptr = prev_ptr;
 
 		} else if ( ( prev_ptr->is_dirty != prev_is_dirty )
-                            ||
-                            ( prev_ptr->next != next_ptr )
-                            ||
-                            ( prev_ptr->is_protected )
-                            ||
-                            ( prev_ptr->is_pinned ) ) {
-
-                    /* something has happened to the LRU -- start over
-                     * from the tail.
-                     */
-
-                    entry_ptr = cache_ptr->LRU_tail_ptr;
+		            ||
+		            ( prev_ptr->next != next_ptr )
+		            ||
+		            ( prev_ptr->is_protected )
+		            ||
+		            ( prev_ptr->is_pinned ) ) {
+
+		    /* something has happened to the LRU -- start over
+		     * from the tail.
+		     */
+	            entry_ptr = cache_ptr->LRU_tail_ptr;
 
-                } else {
+		} else {
 
-                    entry_ptr = prev_ptr;
+		    entry_ptr = prev_ptr;
 
-                }
-            } else {
+		}
+	    } else {
 
-                entry_ptr = NULL;
+		entry_ptr = NULL;
 
-            }
+	    }
 
-            entries_examined++;
+	    entries_examined++;
 
 	    if ( cache_ptr->index_size >= cache_ptr->max_cache_size ) {
 
@@ -9198,7 +9180,6 @@ H5C_make_space_in_cache(H5F_t *	f,
 #if H5C_COLLECT_CACHE_STATS
         cache_ptr->calls_to_msic++;
 
-
         cache_ptr->total_entries_skipped_in_msic += clean_entries_skipped;
         cache_ptr->total_entries_scanned_in_msic += total_entries_scanned;
 
@@ -9255,7 +9236,6 @@ H5C_make_space_in_cache(H5F_t *	f,
             result = H5C_flush_single_entry(f,
                                             primary_dxpl_id,
                                             secondary_dxpl_id,
-                                            cache_ptr,
                                             entry_ptr->type,
                                             entry_ptr->addr,
                                             H5C__FLUSH_INVALIDATE_FLAG,
@@ -9322,13 +9302,11 @@ H5C_validate_lru_list(H5C_t * cache_ptr)
          ( cache_ptr->LRU_head_ptr != cache_ptr->LRU_tail_ptr )
        ) {
 
-        HDfprintf(stdout,"H5C_validate_lru_list: Check 1 failed.\n");
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 1 failed")
     }
 
     if ( ( cache_ptr->LRU_list_len < 0 ) || ( cache_ptr->LRU_list_size < 0 ) ) {
 
-        HDfprintf(stdout,"H5C_validate_lru_list: Check 2 failed.\n");
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 2 failed")
     }
 
@@ -9342,7 +9320,6 @@ H5C_validate_lru_list(H5C_t * cache_ptr)
          )
        ) {
 
-        HDfprintf(stdout,"H5C_validate_lru_list: Check 3 failed.\n");
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 3 failed")
     }
 
@@ -9358,7 +9335,6 @@ H5C_validate_lru_list(H5C_t * cache_ptr)
          )
        ) {
 
-        HDfprintf(stdout,"H5C_validate_lru_list: Check 4 failed.\n");
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 4 failed")
     }
 
@@ -9370,7 +9346,6 @@ H5C_validate_lru_list(H5C_t * cache_ptr)
              ( ( entry_ptr->prev == NULL ) ||
                ( entry_ptr->prev->next != entry_ptr ) ) ) {
 
-            HDfprintf(stdout,"H5C_validate_lru_list: Check 5 failed.\n");
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 5 failed")
         }
 
@@ -9378,7 +9353,6 @@ H5C_validate_lru_list(H5C_t * cache_ptr)
              ( ( entry_ptr->next == NULL ) ||
                ( entry_ptr->next->prev != entry_ptr ) ) ) {
 
-            HDfprintf(stdout,"H5C_validate_lru_list: Check 6 failed.\n");
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 6 failed")
         }
 
@@ -9390,7 +9364,6 @@ H5C_validate_lru_list(H5C_t * cache_ptr)
     if ( ( cache_ptr->LRU_list_len != len ) ||
          ( cache_ptr->LRU_list_size != size ) ) {
 
-        HDfprintf(stdout,"H5C_validate_lru_list: Check 7 failed.\n");
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 7 failed")
     }
 
@@ -9455,9 +9428,6 @@ H5C_verify_not_in_index(H5C_t * cache_ptr,
         {
             if ( scan_ptr == entry_ptr ) {
 
-                HDfprintf(stdout,
-                          "H5C_verify_not_in_index: entry in index (%d/%d)\n",
-                          i, depth);
                 HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
                             "Entry already in index.")
             }