Cache macro error consistency (#2739)

* Pass failure value consistently to all macro errors

2 files changed, 70 insertions, 86 deletions

diff --git a/src/H5C.c b/src/H5C.c
index f9a41fd..8a97e47 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -1415,7 +1415,7 @@ H5C_mark_entry_dirty(void *thing)
 
         /* Modify cache data structures */
         if (was_clean)
-            H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr)
+            H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr, FAIL)
         if (!entry_ptr->in_slist)
             H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, FAIL)
 
@@ -1498,7 +1498,7 @@ H5C_mark_entry_clean(void *_thing)
 
         /* Modify cache data structures */
         if (was_dirty)
-            H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr)
+            H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr, FAIL)
         if (entry_ptr->in_slist)
             H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE)
 
@@ -1847,23 +1847,23 @@ H5C_resize_entry(void *thing, size_t new_size)
 
         /* update the pinned and/or protected entry list */
         if (entry_ptr->is_pinned)
-            H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr->pel_len), (cache_ptr->pel_size), (entry_ptr->size),
-                                            (new_size))
+            H5C__DLL_UPDATE_FOR_SIZE_CHANGE(cache_ptr->pel_len, cache_ptr->pel_size, entry_ptr->size,
+                                            new_size, FAIL)
         if (entry_ptr->is_protected)
-            H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr->pl_len), (cache_ptr->pl_size), (entry_ptr->size),
-                                            (new_size))
+            H5C__DLL_UPDATE_FOR_SIZE_CHANGE(cache_ptr->pl_len, cache_ptr->pl_size, entry_ptr->size, new_size,
+                                            FAIL)
 
 #ifdef H5_HAVE_PARALLEL
         if (entry_ptr->coll_access)
-            H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr->coll_list_len), (cache_ptr->coll_list_size),
-                                            (entry_ptr->size), (new_size))
+            H5C__DLL_UPDATE_FOR_SIZE_CHANGE(cache_ptr->coll_list_len, cache_ptr->coll_list_size,
+                                            entry_ptr->size, new_size, FAIL)
 #endif /* H5_HAVE_PARALLEL */
 
         /* update statistics just before changing the entry size */
         H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE(cache_ptr, entry_ptr, new_size);
 
         /* update the hash table */
-        H5C__UPDATE_INDEX_FOR_SIZE_CHANGE(cache_ptr, entry_ptr->size, new_size, entry_ptr, was_clean);
+        H5C__UPDATE_INDEX_FOR_SIZE_CHANGE(cache_ptr, entry_ptr->size, new_size, entry_ptr, was_clean, FAIL);
 
         /* if the entry is in the skip list, update that too */
         if (entry_ptr->in_slist)
@@ -2983,7 +2983,7 @@ H5C_unprotect(H5F_t *f, haddr_t addr, void *thing, unsigned flags)
         /* Check for newly dirtied entry */
         if (was_clean && entry_ptr->is_dirty) {
             /* Update index for newly dirtied entry */
-            H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr)
+            H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr, FAIL)
 
             /* If the entry's type has a 'notify' callback send a
              * 'entry dirtied' notice now that the entry is fully
@@ -5924,7 +5924,7 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
          */
         entry_ptr->is_dirty = FALSE;
 
-        H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr);
+        H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr, FAIL);
 
         /* Check for entry changing status and do notifications, etc. */
         if (was_dirty) {
@@ -8084,14 +8084,14 @@ H5C__generate_image(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr)
 
             /* Update the hash table for the size change */
             H5C__UPDATE_INDEX_FOR_SIZE_CHANGE(cache_ptr, entry_ptr->size, new_len, entry_ptr,
-                                              !(entry_ptr->is_dirty));
+                                              !entry_ptr->is_dirty, FAIL);
 
             /* The entry can't be protected since we are in the process of
              * flushing it.  Thus we must update the replacement policy data
              * structures for the size change.  The macro deals with the pinned
              * case.
              */
-            H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_len);
+            H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_len, FAIL);
 
             /* As we haven't updated the cache data structures for
              * for the flush or flush destroy yet, the entry should
diff --git a/src/H5Cpkg.h b/src/H5Cpkg.h
index a0acc66..e2f4271 100644
--- a/src/H5Cpkg.h
+++ b/src/H5Cpkg.h
@@ -144,20 +144,20 @@ if ( ( (entry_ptr) == NULL ) ||                                              \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "DLL pre insert SC failed")     \
 }
 
-#define H5C__DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size)    \
+#define H5C__DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)    \
 if ( ( (dll_len) <= 0 ) ||                                                    \
      ( (dll_size) <= 0 ) ||                                                   \
      ( (old_size) <= 0 ) ||                                                   \
      ( (old_size) > (dll_size) ) ||                                           \
      ( (new_size) <= 0 ) ||                                                   \
      ( ( (dll_len) == 1 ) && ( (old_size) != (dll_size) ) ) ) {               \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "DLL pre size update SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "DLL pre size update SC failed") \
 }
 
-#define H5C__DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size)    \
+#define H5C__DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)    \
 if ( ( (new_size) > (dll_size) ) ||                                            \
      ( ( (dll_len) == 1 ) && ( (new_size) != (dll_size) ) ) ) {                \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "DLL post size update SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "DLL post size update SC failed") \
 }
 
 #else /* H5C_DO_SANITY_CHECKS */
@@ -165,8 +165,8 @@ if ( ( (new_size) > (dll_size) ) ||                                            \
 #define H5C__DLL_PRE_REMOVE_SC(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)
 #define H5C__DLL_SC(head_ptr, tail_ptr, len, list_size, fail_val)
 #define H5C__DLL_PRE_INSERT_SC(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)
-#define H5C__DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size)
-#define H5C__DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size)
+#define H5C__DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)
+#define H5C__DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)
 
 #endif /* H5C_DO_SANITY_CHECKS */
 
@@ -237,12 +237,12 @@ if ( ( (new_size) > (dll_size) ) ||                                            \
     }                                                                       \
 } /* H5C__DLL_REMOVE() */
 
-#define H5C__DLL_UPDATE_FOR_SIZE_CHANGE(dll_len, dll_size, old_size, new_size) \
+#define H5C__DLL_UPDATE_FOR_SIZE_CHANGE(dll_len, dll_size, old_size, new_size, fail_val) \
 {                                                                              \
-    H5C__DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size)         \
+    H5C__DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)         \
     (dll_size) -= (old_size);                                                  \
     (dll_size) += (new_size);                                                  \
-    H5C__DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size)        \
+    H5C__DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)        \
 } /* H5C__DLL_UPDATE_FOR_SIZE_CHANGE() */
 
 #ifdef H5C_DO_SANITY_CHECKS
@@ -402,7 +402,6 @@ if ( ( (hd_ptr) == NULL ) ||                                                  \
        )                                                                      \
      )                                                                        \
    ) {                                                                        \
-    HDassert(0 && "il DLL pre remove SC failed");                             \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "il DLL pre remove SC failed")   \
 }
 
@@ -424,7 +423,6 @@ if ( ( (entry_ptr) == NULL ) ||                                               \
        )                                                                      \
      )                                                                        \
    ) {                                                                        \
-    HDassert(0 && "IL DLL pre insert SC failed");                             \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "IL DLL pre insert SC failed")   \
 }
 
@@ -443,7 +441,6 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) &&             \
        )                                                                   \
      )                                                                     \
    ) {                                                                     \
-    HDassert(0 && "IL DLL sanity check failed");                           \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "IL DLL sanity check failed") \
 }
 
@@ -853,7 +850,6 @@ if ( ( (cache_ptr) == NULL ) ||                                         \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ||     \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||               \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {            \
-    HDassert(FALSE);                                                    \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "pre HT insert SC failed") \
 }
 
@@ -875,11 +871,10 @@ if ( ( (cache_ptr) == NULL ) ||                                         \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ||     \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||               \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size) ) {             \
-    HDassert(FALSE);                                                    \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post HT insert SC failed") \
 }
 
-#define H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr)                     \
+#define H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)                     \
 if ( ( (cache_ptr) == NULL ) ||                                         \
      ( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) ||                      \
      ( (cache_ptr)->index_len < 1 ) ||                                  \
@@ -916,11 +911,10 @@ if ( ( (cache_ptr) == NULL ) ||                                         \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ||     \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||               \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {            \
-    HDassert(FALSE);                                                    \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT remove SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT remove SC failed") \
 }
 
-#define H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr)                     \
+#define H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)                     \
 if ( ( (cache_ptr) == NULL ) ||                                          \
      ( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) ||                       \
      ( (entry_ptr) == NULL ) ||                                          \
@@ -942,8 +936,7 @@ if ( ( (cache_ptr) == NULL ) ||                                          \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ||      \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||                \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {             \
-    HDassert(FALSE);                                                     \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT remove SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post HT remove SC failed") \
 }
 
 /* (Keep in sync w/H5C_TEST__PRE_HT_SEARCH_SC macro in test/cache_common.h -QAK) */
@@ -955,7 +948,7 @@ if ( ( (cache_ptr) == NULL ) ||                                             \
      ( ! H5F_addr_defined(Addr) ) ||                                        \
      ( H5C__HASH_FCN(Addr) < 0 ) ||                                         \
      ( H5C__HASH_FCN(Addr) >= H5C__HASH_TABLE_LEN ) ) {                     \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "pre HT search SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT search SC failed") \
 }
 
 /* (Keep in sync w/H5C_TEST__POST_SUC_HT_SEARCH_SC macro in test/cache_common.h -QAK) */
@@ -977,7 +970,7 @@ if ( ( (cache_ptr) == NULL ) ||                                             \
        ( (entry_ptr)->ht_prev->ht_next != (entry_ptr) ) ) ||                \
      ( ( (entry_ptr)->ht_next != NULL ) &&                                  \
        ( (entry_ptr)->ht_next->ht_prev != (entry_ptr) ) ) ) {               \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post successful HT search SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post successful HT search SC failed") \
 }
 
 /* (Keep in sync w/H5C_TEST__POST_HT_SHIFT_TO_FRONT macro in test/cache_common.h -QAK) */
@@ -985,11 +978,11 @@ if ( ( (cache_ptr) == NULL ) ||                                             \
 if ( ( (cache_ptr) == NULL ) ||                                        \
      ( ((cache_ptr)->index)[k] != (entry_ptr) ) ||                     \
      ( (entry_ptr)->ht_prev != NULL ) ) {                              \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post HT shift to front SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post HT shift to front SC failed") \
 }
 
 #define H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, \
-                                entry_ptr, was_clean)                   \
+                                entry_ptr, was_clean, fail_val)                   \
 if ( ( (cache_ptr) == NULL ) ||                                         \
      ( (cache_ptr)->index_len <= 0 ) ||                                 \
      ( (cache_ptr)->index_size <= 0 ) ||                                \
@@ -1019,12 +1012,11 @@ if ( ( (cache_ptr) == NULL ) ||                                         \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ||     \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||               \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {            \
-    HDassert(FALSE);                                                    \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT entry size change SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT entry size change SC failed") \
 }
 
 #define H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size,  \
-                                entry_ptr)                                \
+                                entry_ptr, fail_val)                                \
 if ( ( (cache_ptr) == NULL ) ||                                           \
      ( (cache_ptr)->index_len <= 0 ) ||                                   \
      ( (cache_ptr)->index_size <= 0 ) ||                                  \
@@ -1049,11 +1041,10 @@ if ( ( (cache_ptr) == NULL ) ||                                           \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ||       \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||                 \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {              \
-    HDassert(FALSE);                                                      \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT entry size change SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post HT entry size change SC failed") \
 }
 
-#define H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr)           \
+#define H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val)           \
 if (                                                                          \
     ( (cache_ptr) == NULL ) ||                                                \
     ( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) ||                             \
@@ -1076,11 +1067,10 @@ if (                                                                          \
     ( (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                      \
       ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                \
        (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ) {           \
-    HDassert(FALSE);                                                          \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT update for entry clean SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT update for entry clean SC failed") \
 }
 
-#define H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr)           \
+#define H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val)           \
 if (                                                                          \
     ( (cache_ptr) == NULL ) ||                                                \
     ( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) ||                             \
@@ -1103,11 +1093,10 @@ if (                                                                          \
     ( (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                      \
       ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                \
        (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ) {           \
-    HDassert(FALSE);                                                          \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT update for entry dirty SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT update for entry dirty SC failed") \
 }
 
-#define H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr)        \
+#define H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val)        \
 if ( ( (cache_ptr)->index_size !=                                           \
        ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ) || \
      ( (cache_ptr)->index_size < ((cache_ptr)->clean_index_size) ) ||       \
@@ -1119,11 +1108,10 @@ if ( ( (cache_ptr)->index_size !=                                           \
      ( (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                   \
        ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +             \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ) {        \
-    HDassert(FALSE);                                                        \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT update for entry clean SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post HT update for entry clean SC failed") \
 }
 
-#define H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr)        \
+#define H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val)        \
 if ( ( (cache_ptr)->index_size !=                                           \
        ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ) || \
      ( (cache_ptr)->index_size < ((cache_ptr)->clean_index_size) ) ||       \
@@ -1135,27 +1123,26 @@ if ( ( (cache_ptr)->index_size !=                                           \
      ( (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                   \
        ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +             \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ) {        \
-    HDassert(FALSE);                                                        \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT update for entry dirty SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post HT update for entry dirty SC failed") \
 }
 
 #else /* H5C_DO_SANITY_CHECKS */
 
 #define H5C__PRE_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val)
 #define H5C__POST_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val)
-#define H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr)
-#define H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr)
+#define H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)
+#define H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)
 #define H5C__PRE_HT_SEARCH_SC(cache_ptr, Addr, fail_val)
 #define H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, k, fail_val)
 #define H5C__POST_HT_SHIFT_TO_FRONT(cache_ptr, entry_ptr, k, fail_val)
-#define H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr)
-#define H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr)
+#define H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val)
+#define H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val)
 #define H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, \
-                                entry_ptr, was_clean)
+                                entry_ptr, was_clean, fail_val)
 #define H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, \
-                                entry_ptr)
-#define H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr)
-#define H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr)
+                                entry_ptr, fail_val)
+#define H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val)
+#define H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val)
 
 #endif /* H5C_DO_SANITY_CHECKS */
 
@@ -1198,7 +1185,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
 #define H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr, fail_val)               \
 {                                                                            \
     int k;                                                                   \
-    H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr)                              \
+    H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)                              \
     k = H5C__HASH_FCN((entry_ptr)->addr);                                    \
     if((entry_ptr)->ht_next)                                                 \
         (entry_ptr)->ht_next->ht_prev = (entry_ptr)->ht_prev;                \
@@ -1230,7 +1217,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
                        (cache_ptr)->il_tail, (cache_ptr)->il_len,            \
                        (cache_ptr)->il_size, fail_val)                       \
     H5C__UPDATE_STATS_FOR_HT_DELETION(cache_ptr)                             \
-    H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr)                             \
+    H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)                             \
 }
 
 #define H5C__SEARCH_INDEX(cache_ptr, Addr, entry_ptr, fail_val)             \
@@ -1262,35 +1249,35 @@ if ( ( (cache_ptr)->index_size !=                                           \
     H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, (entry_ptr != NULL), depth)  \
 }
 
-#define H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr)   \
+#define H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr, fail_val)   \
 {                                                                 \
-    H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr);  \
+    H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val)  \
     (cache_ptr)->dirty_index_size -= (entry_ptr)->size;           \
     ((cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring])         \
         -= (entry_ptr)->size;                                     \
     (cache_ptr)->clean_index_size += (entry_ptr)->size;           \
     ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring])         \
         += (entry_ptr)->size;                                     \
-    H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr); \
+    H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val) \
 }
 
-#define H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr)   \
+#define H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr, fail_val)   \
 {                                                                 \
-    H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr);  \
+    H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val)  \
     (cache_ptr)->clean_index_size -= (entry_ptr)->size;           \
     ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring])         \
         -= (entry_ptr)->size;                                     \
     (cache_ptr)->dirty_index_size += (entry_ptr)->size;           \
     ((cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring])         \
         += (entry_ptr)->size;                                     \
-    H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr); \
+    H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val) \
 }
 
 #define H5C__UPDATE_INDEX_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size,    \
-                                entry_ptr, was_clean)                       \
+                                entry_ptr, was_clean, fail_val)                       \
 {                                                                           \
     H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size,         \
-                            entry_ptr, was_clean)                           \
+                            entry_ptr, was_clean, fail_val)                           \
     (cache_ptr)->index_size -= (old_size);                                  \
     (cache_ptr)->index_size += (new_size);                                  \
     ((cache_ptr)->index_ring_size[(entry_ptr)->ring]) -= (old_size);          \
@@ -1311,9 +1298,9 @@ if ( ( (cache_ptr)->index_size !=                                           \
     }                                                                       \
     H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->il_len,                    \
                                     (cache_ptr)->il_size,                   \
-                                    (old_size), (new_size))                 \
+                                    (old_size), (new_size), (fail_val))                 \
     H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size,        \
-                                      entry_ptr)                            \
+                                      entry_ptr, fail_val)                            \
 }
 
 
@@ -2389,7 +2376,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
 
-#define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)    \
+#define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size, fail_val)    \
 {                                                                         \
     HDassert( (cache_ptr) );                                              \
     HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
@@ -2405,7 +2392,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
     H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->coll_list_len,           \
                                     (cache_ptr)->coll_list_size,          \
                                     (entry_ptr)->size,                    \
-                                    (new_size));                          \
+                                    (new_size), (fail_val));                          \
                                                                           \
     }                                                                     \
                                                                           \
@@ -2414,7 +2401,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
         H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->pel_len,             \
                                     (cache_ptr)->pel_size,                \
                                     (entry_ptr)->size,                    \
-                                    (new_size));                          \
+                                    (new_size), (fail_val));                          \
                                                                           \
     } else {                                                              \
                                                                           \
@@ -2425,7 +2412,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
         H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->LRU_list_len,        \
                                         (cache_ptr)->LRU_list_size,       \
                                         (entry_ptr)->size,                \
-                                        (new_size));                      \
+                                        (new_size), (fail_val));                      \
                                                                           \
         /* Similarly, update the size of the clean or dirty LRU list as   \
          * appropriate.  At present, the entry must be clean, but that    \
@@ -2437,14 +2424,14 @@ if ( ( (cache_ptr)->index_size !=                                           \
             H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->dLRU_list_len,   \
                                             (cache_ptr)->dLRU_list_size,  \
                                             (entry_ptr)->size,            \
-                                            (new_size));                  \
+                                            (new_size), (fail_val));                  \
                                                                           \
         } else {                                                          \
                                                                           \
             H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->cLRU_list_len,   \
                                             (cache_ptr)->cLRU_list_size,  \
                                             (entry_ptr)->size,            \
-                                            (new_size));                  \
+                                            (new_size), (fail_val));                  \
         }                                                                 \
                                                                           \
         /* End modified LRU specific code. */                             \
@@ -2454,7 +2441,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #else /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
 
-#define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)    \
+#define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size, fail_val)    \
 {                                                                         \
     HDassert( (cache_ptr) );                                              \
     HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
@@ -2470,7 +2457,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
         H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->pel_len,             \
                                         (cache_ptr)->pel_size,            \
                                         (entry_ptr)->size,                \
-                                        (new_size));                      \
+                                        (new_size), (fail_val));                      \
                                                                           \
     } else {                                                              \
                                                                           \
@@ -2481,7 +2468,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
         H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->LRU_list_len,        \
                                         (cache_ptr)->LRU_list_size,       \
                                         (entry_ptr)->size,                \
-                                        (new_size));                      \
+                                        (new_size), (fail_val));                      \
                                                                           \
         /* End modified LRU specific code. */                             \
     }                                                                     \
@@ -2751,7 +2738,6 @@ if ( ( (hd_ptr) == NULL ) ||                                                   \
        )                                                                       \
      )                                                                         \
    ) {                                                                         \
-    HDassert(0 && "coll DLL pre remove SC failed");                            \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "coll DLL pre remove SC failed")  \
 }
 
@@ -2772,7 +2758,6 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) &&              \
        )                                                                    \
      )                                                                      \
    ) {                                                                      \
-    HDassert(0 && "COLL DLL sanity check failed");                          \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "COLL DLL sanity check failed")\
 }
 
@@ -2794,7 +2779,6 @@ if ( ( (entry_ptr) == NULL ) ||                                                \
        )                                                                       \
      )                                                                         \
    ) {                                                                         \
-    HDassert(0 && "COLL DLL pre insert SC failed");                            \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "COLL DLL pre insert SC failed")  \
 }