mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-03-25 17:00:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Another round of fixing -Wextra-semi-stmt warnings (#3264)

Browse Source 
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
This commit is contained in:
Sean McBride 2023-07-24 17:18:04 -04:00 committed by GitHub
parent e0083c48e9
commit 553e1cd311
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
186 changed files with 1216 additions and 1205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.clang-format
View File

@ -84,10 +84,7 @@ StatementMacros:
- H5_GCC_DIAG_OFF
- H5_GCC_DIAG_ON
- H5_LEAVE
- HDONE_ERROR
- HERROR
- HGOTO_DONE
- HGOTO_DONE_TAG
- HGOTO_ERROR
- HMPI_DONE_ERROR
- HMPI_ERROR

14
examples/ph5example.c
View File

@ -46,23 +46,25 @@
/* Define some handy debugging shorthands, routines, ... */
/* debugging tools */
#define MESG(x) \
if (verbose) \
printf("%s\n", x);
do { \
if (verbose) \
printf("%s\n", x); \
} while (0)
#define MPI_BANNER(mesg) \
{ \
do { \
printf("--------------------------------\n"); \
printf("Proc %d: ", mpi_rank); \
printf("*** %s\n", mesg); \
printf("--------------------------------\n"); \
}
} while (0)
#define SYNC(comm) \
{ \
do { \
MPI_BANNER("doing a SYNC"); \
MPI_Barrier(comm); \
MPI_BANNER("SYNC DONE"); \
}
} while (0)
/* End of Define some handy debugging shorthands, routines, ... */
/* Constants definitions */

16
src/H5A.c
View File

@ -136,7 +136,7 @@ done:
/* Cleanup on failure */
if (H5I_INVALID_HID == ret_value)
if (attr && H5VL_attr_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__create_common() */
@ -278,7 +278,7 @@ H5Acreate_async(const char *app_file, const char *app_func, unsigned app_line, h
H5ARG_TRACE10(__func__, "*s*sIui*siiiii", app_file, app_func, app_line, loc_id, attr_name, type_id, space_id, acpl_id, aapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref(ret_value) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID");
HGOTO_ERROR(H5E_ATTR, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -427,7 +427,7 @@ H5Acreate_by_name_async(const char *app_file, const char *app_func, unsigned app
H5ARG_TRACE12(__func__, "*s*sIui*s*siiiiii", app_file, app_func, app_line, loc_id, obj_name, attr_name, type_id, space_id, acpl_id, aapl_id, lapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref(ret_value) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID");
HGOTO_ERROR(H5E_ATTR, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -471,7 +471,7 @@ done:
/* Cleanup on failure */
if (H5I_INVALID_HID == ret_value)
if (attr && H5VL_attr_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__open_common() */
@ -590,7 +590,7 @@ H5Aopen_async(const char *app_file, const char *app_func, unsigned app_line, hid
H5ARG_TRACE7(__func__, "*s*sIui*sii", app_file, app_func, app_line, loc_id, attr_name, aapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref(ret_value) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID");
HGOTO_ERROR(H5E_ATTR, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -721,7 +721,7 @@ H5Aopen_by_name_async(const char *app_file, const char *app_func, unsigned app_l
H5ARG_TRACE9(__func__, "*s*sIui*s*siii", app_file, app_func, app_line, loc_id, obj_name, attr_name, aapl_id, lapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref(ret_value) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID");
HGOTO_ERROR(H5E_ATTR, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -861,7 +861,7 @@ H5Aopen_by_idx_async(const char *app_file, const char *app_func, unsigned app_li
H5ARG_TRACE11(__func__, "*s*sIui*sIiIohiii", app_file, app_func, app_line, loc_id, obj_name, idx_type, order, n, aapl_id, lapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref(ret_value) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on attribute ID");
HGOTO_ERROR(H5E_ATTR, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -2288,7 +2288,7 @@ H5Aclose_async(const char *app_file, const char *app_func, unsigned app_line, hi
done:
if (connector && H5VL_conn_dec_rc(connector) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "can't decrement ref count on connector")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "can't decrement ref count on connector");
FUNC_LEAVE_API(ret_value)
} /* H5Aclose_async() */

40
src/H5AC.c
View File

@ -366,7 +366,7 @@ done:
/* If currently logging, generate a message */
if (f->shared->cache->log_info->logging)
if (H5C_log_write_create_cache_msg(f->shared->cache, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
#ifdef H5_HAVE_PARALLEL
/* if there is a failure, try to tidy up the auxiliary structure */
@ -533,7 +533,7 @@ done:
/* If currently logging, generate a message */
if (f->shared->cache->log_info->logging)
if (H5C_log_write_evict_cache_msg(f->shared->cache, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_evict() */
@ -571,7 +571,7 @@ done:
/* If currently logging, generate a message */
if (f->shared->cache->log_info->logging)
if (H5C_log_write_expunge_entry_msg(f->shared->cache, addr, type->id, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_expunge_entry() */
@ -623,7 +623,7 @@ done:
/* If currently logging, generate a message */
if (f->shared->cache->log_info->logging)
if (H5C_log_write_flush_cache_msg(f->shared->cache, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_flush() */
@ -754,7 +754,7 @@ done:
if (f->shared->cache->log_info->logging)
if (H5C_log_write_insert_entry_msg(f->shared->cache, addr, type->id, flags,
((H5C_cache_entry_t *)thing)->size, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_insert_entry() */
@ -835,7 +835,7 @@ done:
if (cache_ptr != NULL && cache_ptr->log_info != NULL)
if (cache_ptr->log_info->logging)
if (H5C_log_write_mark_entry_dirty_msg(cache_ptr, entry_ptr, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_mark_entry_dirty() */
@ -885,7 +885,7 @@ done:
if (cache_ptr != NULL && cache_ptr->log_info != NULL)
if (cache_ptr->log_info->logging)
if (H5C_log_write_mark_entry_clean_msg(cache_ptr, entry_ptr, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_mark_entry_clean() */
@ -924,7 +924,7 @@ done:
if (cache_ptr != NULL && cache_ptr->log_info != NULL)
if (cache_ptr->log_info->logging)
if (H5C_log_write_mark_unserialized_entry_msg(cache_ptr, entry_ptr, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_mark_entry_unserialized() */
@ -962,7 +962,7 @@ done:
if (cache_ptr != NULL && cache_ptr->log_info != NULL)
if (cache_ptr->log_info->logging)
if (H5C_log_write_mark_serialized_entry_msg(cache_ptr, entry_ptr, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_mark_entry_serialized() */
@ -1016,7 +1016,7 @@ done:
/* If currently logging, generate a message */
if (f->shared->cache->log_info->logging)
if (H5C_log_write_move_entry_msg(f->shared->cache, old_addr, new_addr, type->id, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_move_entry() */
@ -1056,7 +1056,7 @@ done:
if (cache_ptr != NULL && cache_ptr->log_info != NULL)
if (cache_ptr->log_info->logging)
if (H5C_log_write_pin_entry_msg(cache_ptr, entry_ptr, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_pin_protected_entry() */
@ -1213,7 +1213,7 @@ done:
if (cache_ptr->log_info->logging)
if (H5C_log_write_create_fd_msg(cache_ptr, (H5AC_info_t *)parent_thing,
(H5AC_info_t *)child_thing, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_create_flush_dependency() */
@ -1287,7 +1287,7 @@ done:
if (f->shared->cache->log_info->logging)
if (H5C_log_write_protect_entry_msg(f->shared->cache, (H5AC_info_t *)thing, type->id, flags,
fake_ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, NULL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, NULL, "unable to emit log message");
}
FUNC_LEAVE_NOAPI(ret_value)
@ -1381,7 +1381,7 @@ done:
if (cache_ptr != NULL && cache_ptr->log_info != NULL)
if (cache_ptr->log_info->logging)
if (H5C_log_write_resize_entry_msg(cache_ptr, entry_ptr, new_size, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_resize_entry() */
@ -1421,7 +1421,7 @@ done:
if (cache_ptr != NULL && cache_ptr->log_info != NULL)
if (cache_ptr->log_info->logging)
if (H5C_log_write_unpin_entry_msg(cache_ptr, entry_ptr, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_unpin_entry() */
@ -1462,7 +1462,7 @@ done:
if (cache_ptr->log_info->logging)
if (H5C_log_write_destroy_fd_msg(cache_ptr, (H5AC_info_t *)parent_thing,
(H5AC_info_t *)child_thing, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_destroy_flush_dependency() */
@ -1553,7 +1553,7 @@ H5AC_unprotect(H5F_t *f, const H5AC_class_t *type, haddr_t addr, void *thing, un
/* If we fail to log the deleted entry, push an error but still
* participate in a possible sync point ahead
*/
HDONE_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "H5AC__log_deleted_entry() failed")
HDONE_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "H5AC__log_deleted_entry() failed");
}
}
} /* end if */
@ -1573,7 +1573,7 @@ done:
/* If currently logging, generate a message */
if (f->shared->cache->log_info->logging)
if (H5C_log_write_unprotect_entry_msg(f->shared->cache, addr, type->id, flags, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_unprotect() */
@ -1828,7 +1828,7 @@ done:
/* If currently logging, generate a message */
if (cache_ptr->log_info->logging)
if (H5C_log_write_set_cache_config_msg(cache_ptr, config_ptr, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_set_cache_auto_resize_config() */
@ -2532,7 +2532,7 @@ done:
if (cache != NULL && cache->log_info != NULL)
if (cache->log_info->logging)
if (H5C_log_write_remove_entry_msg(cache, entry, ret_value) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_remove_entry() */

14
src/H5ACmpio.c
View File

@ -288,7 +288,7 @@ H5AC__broadcast_candidate_list(H5AC_t *cache_ptr, unsigned *num_entries_ptr, had
*/
if (H5AC__copy_candidate_list_to_buffer(cache_ptr, &chk_num_entries, &haddr_buf_ptr) < 0) {
/* Push an error, but still participate in following MPI_Bcast */
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't construct candidate buffer.")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't construct candidate buffer.");
}
assert(chk_num_entries == num_entries);
assert(haddr_buf_ptr != NULL);
@ -409,7 +409,7 @@ H5AC__broadcast_clean_list(H5AC_t *cache_ptr)
buf_size = sizeof(haddr_t) * num_entries;
if (NULL == (addr_buf_ptr = (haddr_t *)H5MM_malloc(buf_size))) {
/* Push an error, but still participate in following MPI_Bcast */
HDONE_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for addr buffer")
HDONE_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for addr buffer");
}
else {
/* Set up user data for callback */
@ -421,7 +421,7 @@ H5AC__broadcast_clean_list(H5AC_t *cache_ptr)
/* (Callback also removes the matching entries from the dirtied list) */
if (H5SL_free(aux_ptr->c_slist_ptr, H5AC__broadcast_clean_list_cb, &udata) < 0) {
/* Push an error, but still participate in following MPI_Bcast */
HDONE_ERROR(H5E_CACHE, H5E_CANTFREE, FAIL, "Can't build address list for clean entries")
HDONE_ERROR(H5E_CACHE, H5E_CANTFREE, FAIL, "Can't build address list for clean entries");
}
}
@ -1396,7 +1396,7 @@ H5AC__receive_haddr_list(MPI_Comm mpi_comm, unsigned *num_entries_ptr, haddr_t *
buf_size = sizeof(haddr_t) * num_entries;
if (NULL == (haddr_buf_ptr = (haddr_t *)H5MM_malloc(buf_size))) {
/* Push an error, but still participate in following MPI_Bcast */
HDONE_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for haddr buffer")
HDONE_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for haddr buffer");
}
/* Now receive the list of candidate entries */
@ -1740,7 +1740,7 @@ H5AC__rsp__dist_md_write__flush_to_min_clean(H5F_t *f)
*/
if (H5AC__construct_candidate_list(cache_ptr, aux_ptr, H5AC_SYNC_POINT_OP__FLUSH_TO_MIN_CLEAN) <
0)
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't construct candidate list.")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't construct candidate list.");
}
/* propagate and apply candidate list -- all processes */
@ -1833,7 +1833,7 @@ H5AC__rsp__p0_only__flush(H5F_t *f)
* in collective operations during following cache entry
* propagation
*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush.")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush.");
}
else {
/* this code exists primarily for the test bed -- it allows us to
@ -1955,7 +1955,7 @@ H5AC__rsp__p0_only__flush_to_min_clean(H5F_t *f)
* in collective operations during following cache entry
* propagation
*/
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_flush_to_min_clean() failed.")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_flush_to_min_clean() failed.");
}
else {
/* this call exists primarily for the test code -- it is used

2
src/H5Abtree2.c
View File

@ -456,7 +456,7 @@ H5A__dense_btree2_corder_decode(const uint8_t *raw, void *_nrecord, void H5_ATTR
H5MM_memcpy(nrecord->id.id, raw, (size_t)H5O_FHEAP_ID_LEN);
raw += H5O_FHEAP_ID_LEN;
nrecord->flags = *raw++;
UINT32DECODE(raw, nrecord->corder)
UINT32DECODE(raw, nrecord->corder);
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5A__dense_btree2_corder_decode() */

74
src/H5Adense.c
View File

@ -244,11 +244,11 @@ H5A__dense_create(H5F_t *f, H5O_ainfo_t *ainfo)
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
if (bt2_corder && H5B2_close(bt2_corder) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_create() */
@ -385,11 +385,11 @@ H5A__dense_open(H5F_t *f, const H5O_ainfo_t *ainfo, const char *name)
done:
/* Release resources */
if (shared_fheap && H5HF_close(shared_fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, NULL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, NULL, "can't close fractal heap");
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, NULL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, NULL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, NULL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, NULL, "can't close v2 B-tree for name index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_open() */
@ -533,15 +533,15 @@ H5A__dense_insert(H5F_t *f, const H5O_ainfo_t *ainfo, H5A_t *attr)
done:
/* Release resources */
if (shared_fheap && H5HF_close(shared_fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
if (bt2_corder && H5B2_close(bt2_corder) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index");
if (wb && H5WB_unwrap(wb) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_insert() */
@ -679,9 +679,9 @@ H5A__dense_write_bt2_cb(void *_record, void *_op_data, hbool_t *changed)
done:
/* Release resources */
if (bt2_corder && H5B2_close(bt2_corder) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index");
if (wb && H5WB_unwrap(wb) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_write_bt2_cb() */
@ -768,11 +768,11 @@ H5A__dense_write(H5F_t *f, const H5O_ainfo_t *ainfo, H5A_t *attr)
done:
/* Release resources */
if (shared_fheap && H5HF_close(shared_fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_write() */
@ -983,13 +983,13 @@ H5A__dense_rename(H5F_t *f, const H5O_ainfo_t *ainfo, const char *old_name, cons
done:
/* Release resources */
if (shared_fheap && H5HF_close(shared_fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
if (bt2_corder && H5B2_close(bt2_corder) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index");
if (attr_copy)
H5O_msg_free(H5O_ATTR_ID, attr_copy);
@ -1208,13 +1208,13 @@ H5A__dense_iterate(H5F_t *f, hid_t loc_id, const H5O_ainfo_t *ainfo, H5_index_t
done:
/* Release resources */
if (shared_fheap && H5HF_close(shared_fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index");
if (atable.attrs && H5A__attr_release_table(&atable) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "unable to release attribute table")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "unable to release attribute table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_iterate() */
@ -1274,7 +1274,7 @@ H5A__dense_remove_bt2_cb(const void *_record, void *_udata)
done:
/* Release resources */
if (bt2_corder && H5B2_close(bt2_corder) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_remove_bt2_cb() */
@ -1351,11 +1351,11 @@ H5A__dense_remove(H5F_t *f, const H5O_ainfo_t *ainfo, const char *name)
done:
/* Release resources */
if (shared_fheap && H5HF_close(shared_fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
if (attr_copy)
H5O_msg_free_real(H5O_MSG_ATTR, attr_copy);
@ -1477,7 +1477,7 @@ H5A__dense_remove_by_idx_bt2_cb(const void *_record, void *_bt2_udata)
done:
/* Release resources */
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index");
if (fh_udata.attr)
H5O_msg_free(H5O_ATTR_ID, fh_udata.attr);
@ -1596,13 +1596,13 @@ H5A__dense_remove_by_idx(H5F_t *f, const H5O_ainfo_t *ainfo, H5_index_t idx_type
done:
/* Release resources */
if (shared_fheap && H5HF_close(shared_fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index");
if (atable.attrs && H5A__attr_release_table(&atable) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "unable to release attribute table")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "unable to release attribute table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_remove_by_idx() */
@ -1681,11 +1681,11 @@ H5A__dense_exists(H5F_t *f, const H5O_ainfo_t *ainfo, const char *name, hbool_t
done:
/* Release resources */
if (shared_fheap && H5HF_close(shared_fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_exists() */
@ -1812,7 +1812,7 @@ H5A__dense_delete(H5F_t *f, H5O_ainfo_t *ainfo)
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_delete() */

6
src/H5Adeprec.c
View File

@ -147,7 +147,7 @@ done:
/* Clean up on failure */
if (H5I_INVALID_HID == ret_value)
if (attr && H5VL_attr_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute");
FUNC_LEAVE_API(ret_value)
} /* end H5Acreate1() */
@ -212,7 +212,7 @@ done:
/* Clean up on failure */
if (H5I_INVALID_HID == ret_value)
if (attr && H5VL_attr_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute");
FUNC_LEAVE_API(ret_value)
} /* H5Aopen_name() */
@ -280,7 +280,7 @@ done:
/* Clean up on failure */
if (H5I_INVALID_HID == ret_value)
if (attr && H5VL_attr_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "can't close attribute");
FUNC_LEAVE_API(ret_value)
} /* H5Aopen_idx() */

60
src/H5Aint.c
View File

@ -382,7 +382,7 @@ H5A__create(const H5G_loc_t *loc, const char *attr_name, const H5T_t *type, cons
done:
/* Cleanup on failure */
if (NULL == ret_value && attr && H5A__close(attr))
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute");
FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* H5A__create() */
@ -434,12 +434,12 @@ H5A__create_by_name(const H5G_loc_t *loc, const char *obj_name, const char *attr
done:
/* Release resources */
if (loc_found && H5G_loc_free(&obj_loc) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, NULL, "can't free location")
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, NULL, "can't free location");
/* Cleanup on failure */
if (ret_value == NULL)
if (attr && H5A__close(attr) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__create_by_name() */
@ -533,7 +533,7 @@ done:
/* Cleanup on failure */
if (ret_value == NULL)
if (attr && H5A__close(attr) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__open() */
@ -588,12 +588,12 @@ H5A__open_by_idx(const H5G_loc_t *loc, const char *obj_name, H5_index_t idx_type
done:
/* Release resources */
if (loc_found && H5G_loc_free(&obj_loc) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, NULL, "can't free location")
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, NULL, "can't free location");
/* Cleanup on failure */
if (ret_value == NULL)
if (attr && H5A__close(attr) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__open_by_idx() */
@ -648,12 +648,12 @@ H5A__open_by_name(const H5G_loc_t *loc, const char *obj_name, const char *attr_n
done:
/* Release resources */
if (loc_found && H5G_loc_free(&obj_loc) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, NULL, "can't free location")
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, NULL, "can't free location");
/* Cleanup on failure */
if (ret_value == NULL)
if (attr && H5A__close(attr) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__open_by_name() */
@ -770,9 +770,9 @@ H5A__read(const H5A_t *attr, const H5T_t *mem_type, void *buf)
done:
/* Release resources */
if (src_id >= 0 && H5I_dec_ref(src_id) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "unable to close temporary object")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "unable to close temporary object");
if (dst_id >= 0 && H5I_dec_ref(dst_id) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "unable to close temporary object")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "unable to close temporary object");
if (tconv_buf)
tconv_buf = H5FL_BLK_FREE(attr_buf, tconv_buf);
if (bkg_buf)
@ -908,9 +908,9 @@ H5A__write(H5A_t *attr, const H5T_t *mem_type, const void *buf)
done:
/* Release resources */
if (src_id >= 0 && H5I_dec_ref(src_id) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "unable to close temporary object")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "unable to close temporary object");
if (dst_id >= 0 && H5I_dec_ref(dst_id) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "unable to close temporary object")
HDONE_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "unable to close temporary object");
if (tconv_buf)
tconv_buf = H5FL_BLK_FREE(attr_buf, tconv_buf);
if (bkg_buf)
@ -997,7 +997,7 @@ H5A_get_space(H5A_t *attr)
done:
if (H5I_INVALID_HID == ret_value && ds && H5S_close(ds) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataspace")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataspace");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A_get_space() */
@ -1058,7 +1058,7 @@ H5A__get_type(H5A_t *attr)
done:
if (H5I_INVALID_HID == ret_value)
if (dt && H5T_close(dt) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release datatype")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release datatype");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__get_type() */
@ -1194,7 +1194,7 @@ H5A__copy(H5A_t *_new_attr, const H5A_t *old_attr)
done:
if (ret_value == NULL)
if (allocated_attr && new_attr && H5A__close(new_attr) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__copy() */
@ -1230,12 +1230,12 @@ H5A__shared_free(H5A_t *attr)
}
if (attr->shared->dt) {
if (H5T_close_real(attr->shared->dt) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't release datatype info")
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't release datatype info");
attr->shared->dt = NULL;
}
if (attr->shared->ds) {
if (H5S_close(attr->shared->ds) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't release dataspace info")
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't release dataspace info");
attr->shared->ds = NULL;
}
if (attr->shared->data)
@ -1446,7 +1446,7 @@ H5A__exists_by_name(H5G_loc_t loc, const char *obj_name, const char *attr_name,
done:
/* Release resources */
if (loc_found && H5G_loc_free(&obj_loc) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't free location")
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__exists_by_name() */
@ -1676,7 +1676,7 @@ H5A__dense_build_table(H5F_t *f, const H5O_ainfo_t *ainfo, H5_index_t idx_type,
done:
/* Release resources */
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_build_table() */
@ -1994,7 +1994,7 @@ H5A__get_ainfo(H5F_t *f, H5O_t *oh, H5O_ainfo_t *ainfo)
done:
/* Release resources */
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5A__get_ainfo() */
@ -2314,19 +2314,19 @@ H5A__attr_copy_file(const H5A_t *attr_src, H5F_t *file_dst, hbool_t *recompute_s
done:
if (buf_sid > 0 && H5I_dec_ref(buf_sid) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "Can't decrement temporary dataspace ID")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "Can't decrement temporary dataspace ID");
if (tid_src > 0)
/* Don't decrement ID, we want to keep underlying datatype */
if (NULL == H5I_remove(tid_src))
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "Can't decrement temporary datatype ID");
if (tid_dst > 0)
/* Don't decrement ID, we want to keep underlying datatype */
if (NULL == H5I_remove(tid_dst))
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "Can't decrement temporary datatype ID");
if (tid_mem > 0)
/* Decrement the memory datatype ID, it's transient */
if (H5I_dec_ref(tid_mem) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "Can't decrement temporary datatype ID");
if (buf)
buf = H5FL_BLK_FREE(attr_buf, buf);
if (reclaim_buf)
@ -2336,7 +2336,7 @@ done:
/* Release destination attribute information on failure */
if (!ret_value && attr_dst && H5A__close(attr_dst) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute")
HDONE_ERROR(H5E_ATTR, H5E_CANTFREE, NULL, "can't close attribute");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__attr_copy_file() */
@ -2473,14 +2473,14 @@ H5A__dense_post_copy_file_cb(const H5A_t *attr_src, void *_udata)
/* Insert attribute into dense storage */
if (H5A__dense_insert(udata->file, udata->ainfo, attr_dst) < 0)
HGOTO_ERROR_TAG(H5E_OHDR, H5E_CANTINSERT, H5_ITER_ERROR, "unable to add to dense storage")
HGOTO_ERROR_TAG(H5E_OHDR, H5E_CANTINSERT, H5_ITER_ERROR, "unable to add to dense storage");
/* Reset metadata tag */
H5_END_TAG
done:
if (attr_dst && H5A__close(attr_dst) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close destination attribute")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close destination attribute");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__dense_post_copy_file_cb() */
@ -2567,7 +2567,7 @@ H5A__rename_by_name(H5G_loc_t loc, const char *obj_name, const char *old_attr_na
done:
/* Release resources */
if (loc_found && H5G_loc_free(&obj_loc) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't free location")
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__rename_by_name() */
@ -2743,7 +2743,7 @@ H5A__delete_by_name(const H5G_loc_t *loc, const char *obj_name, const char *attr
done:
/* Release resources */
if (loc_found && H5G_loc_free(&obj_loc) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't free location")
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__delete_by_name() */
@ -2786,7 +2786,7 @@ H5A__delete_by_idx(const H5G_loc_t *loc, const char *obj_name, H5_index_t idx_ty
done:
/* Release resources */
if (loc_found && H5G_loc_free(&obj_loc) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't free location")
HDONE_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5A__delete_by_idx() */

2
src/H5Atest.c
View File

@ -130,7 +130,7 @@ H5A__get_shared_rc_test(hid_t attr_id, hsize_t *ref_count)
done:
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_ATTR, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5A__get_shared_rc_test() */

24
src/H5B.c
View File

@ -249,7 +249,7 @@ done:
if (bt)
/* Destroy B-tree node */
if (H5B__node_dest(bt) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to destroy B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to destroy B-tree node");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -344,7 +344,7 @@ H5B_find(H5F_t *f, const H5B_class_t *type, haddr_t addr, hbool_t *found, void *
done:
if (bt && H5AC_unprotect(f, H5AC_BT, addr, bt, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B_find() */
@ -498,7 +498,7 @@ done:
if (ret_value < 0) {
if (split_bt_ud->bt &&
H5AC_unprotect(f, H5AC_BT, split_bt_ud->addr, split_bt_ud->bt, split_bt_ud->cache_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node");
split_bt_ud->bt = NULL;
split_bt_ud->addr = HADDR_UNDEF;
split_bt_ud->cache_flags = H5AC__NO_FLAGS_SET;
@ -643,11 +643,11 @@ done:
if (bt_ud.bt)
if (H5AC_unprotect(f, H5AC_BT, bt_ud.addr, bt_ud.bt, bt_ud.cache_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to unprotect old root")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to unprotect old root");
if (split_bt_ud.bt)
if (H5AC_unprotect(f, H5AC_BT, split_bt_ud.addr, split_bt_ud.bt, split_bt_ud.cache_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to unprotect new child")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to unprotect new child");
#ifdef H5B_DEBUG
if (ret_value >= 0)
@ -1066,12 +1066,12 @@ H5B__insert_helper(H5F_t *f, H5B_ins_ud_t *bt_ud, const H5B_class_t *type, uint8
done:
if (child_bt_ud.bt)
if (H5AC_unprotect(f, H5AC_BT, child_bt_ud.addr, child_bt_ud.bt, child_bt_ud.cache_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to unprotect child")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to unprotect child");
if (new_child_bt_ud.bt)
if (H5AC_unprotect(f, H5AC_BT, new_child_bt_ud.addr, new_child_bt_ud.bt,
new_child_bt_ud.cache_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to unprotect new child")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to unprotect new child");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B_insert_helper() */
@ -1132,7 +1132,7 @@ H5B__iterate_helper(H5F_t *f, const H5B_class_t *type, haddr_t addr, H5B_operato
done:
if (bt && H5AC_unprotect(f, H5AC_BT, addr, bt, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, H5_ITER_ERROR, "unable to release B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, H5_ITER_ERROR, "unable to release B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B__iterate_helper() */
@ -1498,7 +1498,7 @@ H5B__remove_helper(H5F_t *f, haddr_t addr, const H5B_class_t *type, int level, u
done:
if (bt && H5AC_unprotect(f, H5AC_BT, addr, bt, bt_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to release node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to release node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B__remove_helper() */
@ -1612,7 +1612,7 @@ H5B_delete(H5F_t *f, const H5B_class_t *type, haddr_t addr, void *udata)
done:
if (bt && H5AC_unprotect(f, H5AC_BT, addr, bt, H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node in cache")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node in cache");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B_delete() */
@ -1873,7 +1873,7 @@ H5B__get_info_helper(H5F_t *f, const H5B_class_t *type, haddr_t addr, const H5B_
done:
if (bt && H5AC_unprotect(f, H5AC_BT, addr, bt, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B__get_info_helper() */
@ -1971,7 +1971,7 @@ H5B_valid(H5F_t *f, const H5B_class_t *type, haddr_t addr)
done:
/* Release the node */
if (bt && H5AC_unprotect(f, H5AC_BT, addr, bt, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B_valid() */

16
src/H5B2.c
View File

@ -164,10 +164,10 @@ H5B2_create(H5F_t *f, const H5B2_create_t *cparam, void *ctx_udata)
done:
if (hdr && H5B2__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, NULL, "unable to release v2 B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, NULL, "unable to release v2 B-tree header");
if (!ret_value && bt2)
if (H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTCLOSEOBJ, NULL, "unable to close v2 B-tree")
HDONE_ERROR(H5E_BTREE, H5E_CANTCLOSEOBJ, NULL, "unable to close v2 B-tree");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2_create() */
@ -226,10 +226,10 @@ H5B2_open(H5F_t *f, haddr_t addr, void *ctx_udata)
done:
if (hdr && H5B2__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, NULL, "unable to release v2 B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, NULL, "unable to release v2 B-tree header");
if (!ret_value && bt2)
if (H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTCLOSEOBJ, NULL, "unable to close v2 B-tree")
HDONE_ERROR(H5E_BTREE, H5E_CANTCLOSEOBJ, NULL, "unable to close v2 B-tree");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2_open() */
@ -665,7 +665,7 @@ done:
if (parent) {
assert(ret_value < 0);
if (parent != hdr && H5AC_unpin_entry(parent) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "unable to unpin parent entry")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "unable to unpin parent entry");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -861,7 +861,7 @@ done:
if (parent) {
assert(ret_value < 0);
if (parent != hdr && H5AC_unpin_entry(parent) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "unable to unpin parent entry")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "unable to unpin parent entry");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -1332,7 +1332,7 @@ done:
if (parent) {
assert(ret_value < 0);
if (parent != hdr && H5AC_unpin_entry(parent) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "unable to unpin parent entry")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "unable to unpin parent entry");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -1491,7 +1491,7 @@ H5B2_delete(H5F_t *f, haddr_t addr, void *ctx_udata, H5B2_remove_t op, void *op_
done:
/* Unprotect the header, if an error occurred */
if (hdr && H5B2__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release v2 B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release v2 B-tree header");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2_delete() */

6
src/H5B2cache.c
View File

@ -298,7 +298,7 @@ H5B2__cache_hdr_deserialize(const void *_image, size_t H5_ATTR_UNUSED len, void
done:
if (!ret_value && hdr)
if (H5B2__hdr_free(hdr) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTRELEASE, NULL, "can't release v2 B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_CANTRELEASE, NULL, "can't release v2 B-tree header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__cache_hdr_deserialize() */
@ -691,7 +691,7 @@ H5B2__cache_int_deserialize(const void *_image, size_t H5_ATTR_UNUSED len, void
done:
if (!ret_value && internal)
if (H5B2__internal_free(internal) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, NULL, "unable to destroy B-tree internal node")
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, NULL, "unable to destroy B-tree internal node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__cache_int_deserialize() */
@ -1064,7 +1064,7 @@ H5B2__cache_leaf_deserialize(const void *_image, size_t H5_ATTR_UNUSED len, void
done:
if (!ret_value && leaf)
if (H5B2__leaf_free(leaf) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, NULL, "unable to destroy B-tree leaf node")
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, NULL, "unable to destroy B-tree leaf node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__cache_leaf_deserialize() */

10
src/H5B2dbg.c
View File

@ -131,7 +131,7 @@ H5B2__hdr_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
done:
if (hdr && H5B2__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release v2 B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release v2 B-tree header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__hdr_debug() */
@ -227,9 +227,9 @@ H5B2__int_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, co
done:
if (hdr && H5B2__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release v2 B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release v2 B-tree header");
if (internal && H5AC_unprotect(f, H5AC_BT2_INT, addr, internal, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree internal node")
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree internal node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__int_debug() */
@ -312,9 +312,9 @@ H5B2__leaf_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, c
done:
if (hdr && H5B2__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree header");
if (leaf && H5AC_unprotect(f, H5AC_BT2_LEAF, addr, leaf, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree leaf node")
HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree leaf node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__leaf_debug() */

12
src/H5B2hdr.c
View File

@ -204,7 +204,7 @@ H5B2__hdr_init(H5B2_hdr_t *hdr, const H5B2_create_t *cparam, void *ctx_udata, ui
done:
if (ret_value < 0)
if (H5B2__hdr_free(hdr) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to free shared v2 B-tree info")
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to free shared v2 B-tree info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__hdr_init() */
@ -312,16 +312,16 @@ done:
if (inserted)
if (H5AC_remove_entry(hdr) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTREMOVE, HADDR_UNDEF,
"unable to remove v2 B-tree header from cache")
"unable to remove v2 B-tree header from cache");
/* Release header's disk space */
if (H5_addr_defined(hdr->addr) &&
H5MF_xfree(f, H5FD_MEM_BTREE, hdr->addr, (hsize_t)hdr->hdr_size) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, HADDR_UNDEF, "unable to free v2 B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, HADDR_UNDEF, "unable to free v2 B-tree header");
/* Destroy header */
if (H5B2__hdr_free(hdr) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTRELEASE, HADDR_UNDEF, "unable to release v2 B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_CANTRELEASE, HADDR_UNDEF, "unable to release v2 B-tree header");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -520,7 +520,7 @@ done:
/* Release the header, if it was protected */
if (hdr && H5AC_unprotect(hdr->f, H5AC_BT2_HDR, hdr_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, NULL,
"unable to unprotect v2 B-tree header, address = %llu", (unsigned long long)hdr_addr)
"unable to unprotect v2 B-tree header, address = %llu", (unsigned long long)hdr_addr);
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -674,7 +674,7 @@ H5B2__hdr_delete(H5B2_hdr_t *hdr)
done:
/* Unprotect the header with appropriate flags */
if (H5B2__hdr_unprotect(hdr, cache_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release v2 B-tree header")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release v2 B-tree header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__hdr_delete() */

34
src/H5B2int.c
View File

@ -309,9 +309,9 @@ H5B2__split1(H5B2_hdr_t *hdr, uint16_t depth, H5B2_node_ptr_t *curr_node_ptr,
done:
/* Release child nodes (marked as dirty) */
if (left_child && H5AC_unprotect(hdr->f, child_class, left_addr, left_child, left_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree leaf node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree leaf node");
if (right_child && H5AC_unprotect(hdr->f, child_class, right_addr, right_child, right_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree leaf node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree leaf node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__split1() */
@ -390,7 +390,7 @@ H5B2__split_root(H5B2_hdr_t *hdr)
done:
/* Release new root node (marked as dirty) */
if (new_root && H5AC_unprotect(hdr->f, H5AC_BT2_INT, hdr->root.addr, new_root, new_root_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree internal node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree internal node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__split_root() */
@ -656,9 +656,9 @@ H5B2__redistribute2(H5B2_hdr_t *hdr, uint16_t depth, H5B2_internal_t *internal,
done:
/* Release child nodes (marked as dirty) */
if (left_child && H5AC_unprotect(hdr->f, child_class, left_addr, left_child, left_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
if (right_child && H5AC_unprotect(hdr->f, child_class, right_addr, right_child, right_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__redistribute2() */
@ -1075,12 +1075,12 @@ H5B2__redistribute3(H5B2_hdr_t *hdr, uint16_t depth, H5B2_internal_t *internal,
done:
/* Unlock child nodes (marked as dirty) */
if (left_child && H5AC_unprotect(hdr->f, child_class, left_addr, left_child, left_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
if (middle_child &&
H5AC_unprotect(hdr->f, child_class, middle_addr, middle_child, middle_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
if (right_child && H5AC_unprotect(hdr->f, child_class, right_addr, right_child, right_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__redistribute3() */
@ -1248,11 +1248,11 @@ H5B2__merge2(H5B2_hdr_t *hdr, uint16_t depth, H5B2_node_ptr_t *curr_node_ptr,
done:
/* Unlock left node (marked as dirty) */
if (left_child && H5AC_unprotect(hdr->f, child_class, left_addr, left_child, left_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
/* Delete right node & remove from cache (marked as dirty) */
if (right_child && H5AC_unprotect(hdr->f, child_class, right_addr, right_child, right_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__merge2() */
@ -1510,14 +1510,14 @@ H5B2__merge3(H5B2_hdr_t *hdr, uint16_t depth, H5B2_node_ptr_t *curr_node_ptr,
done:
/* Unlock left & middle nodes (marked as dirty) */
if (left_child && H5AC_unprotect(hdr->f, child_class, left_addr, left_child, left_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
if (middle_child &&
H5AC_unprotect(hdr->f, child_class, middle_addr, middle_child, middle_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
/* Delete right node & remove from cache (marked as dirty) */
if (right_child && H5AC_unprotect(hdr->f, child_class, right_addr, right_child, right_child_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__merge3() */
@ -1683,7 +1683,7 @@ H5B2__iterate_node(H5B2_hdr_t *hdr, uint16_t depth, H5B2_node_ptr_t *curr_node,
done:
/* Unpin the node if it was pinned */
if (node_pinned && H5AC_unpin_entry(node) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "can't unpin node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "can't unpin node");
/* Release the node pointers & native records, if they were copied */
if (node_ptrs)
@ -1770,7 +1770,7 @@ done:
if (node && H5AC_unprotect(
hdr->f, curr_node_class, curr_node->addr, node,
(unsigned)(H5AC__DELETED_FLAG | (hdr->swmr_write ? 0 : H5AC__FREE_FILE_SPACE_FLAG))) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__delete_node() */
@ -1823,7 +1823,7 @@ H5B2__node_size(H5B2_hdr_t *hdr, uint16_t depth, H5B2_node_ptr_t *curr_node, voi
done:
if (internal && H5AC_unprotect(hdr->f, H5AC_BT2_INT, curr_node->addr, internal, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__node_size() */
@ -1946,7 +1946,7 @@ done:
/* Unprotect the child */
if (child)
if (H5AC_unprotect(hdr->f, child_class, node_ptr->addr, child, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__update_flush_depend() */

24
src/H5B2internal.c
View File

@ -145,17 +145,17 @@ done:
if (inserted)
if (H5AC_remove_entry(internal) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTREMOVE, FAIL,
"unable to remove v2 B-tree internal node from cache")
"unable to remove v2 B-tree internal node from cache");
/* Release internal node's disk space */
if (H5_addr_defined(node_ptr->addr) &&
H5MF_xfree(hdr->f, H5FD_MEM_BTREE, node_ptr->addr, (hsize_t)hdr->node_size) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL,
"unable to release file space for v2 B-tree internal node")
"unable to release file space for v2 B-tree internal node");
/* Destroy internal node */
if (H5B2__internal_free(internal) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to release v2 B-tree internal node")
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to release v2 B-tree internal node");
} /* end if */
} /* end if */
@ -229,7 +229,7 @@ done:
if (H5AC_proxy_entry_remove_child(internal->top_proxy, internal) < 0)
HDONE_ERROR(
H5E_BTREE, H5E_CANTUNDEPEND, NULL,
"unable to destroy flush dependency between internal node and v2 B-tree 'top' proxy")
"unable to destroy flush dependency between internal node and v2 B-tree 'top' proxy");
internal->top_proxy = NULL;
} /* end if */
@ -237,7 +237,7 @@ done:
if (H5AC_unprotect(hdr->f, H5AC_BT2_INT, node_ptr->addr, internal, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, NULL,
"unable to unprotect v2 B-tree internal node, address = %llu",
(unsigned long long)node_ptr->addr)
(unsigned long long)node_ptr->addr);
} /* end if */
} /* end if */
@ -325,7 +325,7 @@ done:
/* Release the B-tree internal node */
if (internal &&
H5AC_unprotect(hdr->f, H5AC_BT2_INT, curr_node_ptr->addr, internal, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__neighbor_internal() */
@ -483,11 +483,11 @@ done:
/* Shadow the node if doing SWMR writes */
if (hdr->swmr_write && (internal_flags & H5AC__DIRTIED_FLAG))
if (H5B2__shadow_internal(internal, curr_node_ptr) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTCOPY, FAIL, "unable to shadow internal B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTCOPY, FAIL, "unable to shadow internal B-tree node");
/* Unprotect node */
if (H5AC_unprotect(hdr->f, H5AC_BT2_INT, curr_node_ptr->addr, internal, internal_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -686,7 +686,7 @@ done:
if (hdr->swmr_write && (internal_flags & H5AC__DIRTIED_FLAG)) {
/* Attempt to shadow the node if doing SWMR writes */
if (H5B2__shadow_internal(internal, curr_node_ptr) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTCOPY, FAIL, "unable to shadow internal B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTCOPY, FAIL, "unable to shadow internal B-tree node");
/* Change the state to "shadowed" if only modified currently */
/* (Triggers parent to be marked dirty) */
@ -696,7 +696,7 @@ done:
/* Unprotect node */
if (H5AC_unprotect(hdr->f, H5AC_BT2_INT, curr_node_ptr->addr, internal, internal_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -1002,7 +1002,7 @@ H5B2__remove_internal(H5B2_hdr_t *hdr, hbool_t *depth_decreased, void *swap_loc,
done:
/* Release the B-tree internal node */
if (internal && H5AC_unprotect(hdr->f, H5AC_BT2_INT, internal_addr, internal, internal_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__remove_internal() */
@ -1294,7 +1294,7 @@ H5B2__remove_internal_by_idx(H5B2_hdr_t *hdr, hbool_t *depth_decreased, void *sw
done:
/* Release the B-tree internal node */
if (internal && H5AC_unprotect(hdr->f, H5AC_BT2_INT, internal_addr, internal, internal_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__remove_internal_by_idx() */

26
src/H5B2leaf.c
View File

@ -134,17 +134,17 @@ done:
if (inserted)
if (H5AC_remove_entry(leaf) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTREMOVE, FAIL,
"unable to remove v2 B-tree leaf node from cache")
"unable to remove v2 B-tree leaf node from cache");
/* Release leaf node's disk space */
if (H5_addr_defined(node_ptr->addr) &&
H5MF_xfree(hdr->f, H5FD_MEM_BTREE, node_ptr->addr, (hsize_t)hdr->node_size) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL,
"unable to release file space for v2 B-tree leaf node")
"unable to release file space for v2 B-tree leaf node");
/* Destroy leaf node */
if (H5B2__leaf_free(leaf) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to release v2 B-tree leaf node")
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to release v2 B-tree leaf node");
} /* end if */
} /* end if */
@ -213,7 +213,7 @@ done:
if (H5AC_proxy_entry_remove_child(leaf->top_proxy, leaf) < 0)
HDONE_ERROR(
H5E_BTREE, H5E_CANTUNDEPEND, NULL,
"unable to destroy flush dependency between leaf node and v2 B-tree 'top' proxy")
"unable to destroy flush dependency between leaf node and v2 B-tree 'top' proxy");
leaf->top_proxy = NULL;
} /* end if */
@ -221,7 +221,7 @@ done:
if (H5AC_unprotect(hdr->f, H5AC_BT2_LEAF, node_ptr->addr, leaf, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, NULL,
"unable to unprotect v2 B-tree leaf node, address = %llu",
(unsigned long long)node_ptr->addr)
(unsigned long long)node_ptr->addr);
} /* end if */
} /* end if */
@ -304,7 +304,7 @@ H5B2__neighbor_leaf(H5B2_hdr_t *hdr, H5B2_node_ptr_t *curr_node_ptr, void *neigh
done:
/* Release the B-tree leaf node */
if (leaf && H5AC_unprotect(hdr->f, H5AC_BT2_LEAF, curr_node_ptr->addr, leaf, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree leaf node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree leaf node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__neighbor_leaf() */
@ -407,11 +407,11 @@ done:
/* Shadow the node if doing SWMR writes */
if (hdr->swmr_write && (leaf_flags & H5AC__DIRTIED_FLAG))
if (H5B2__shadow_leaf(leaf, curr_node_ptr) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTCOPY, FAIL, "unable to shadow leaf B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTCOPY, FAIL, "unable to shadow leaf B-tree node");
/* Unprotect leaf node */
if (H5AC_unprotect(hdr->f, H5AC_BT2_LEAF, curr_node_ptr->addr, leaf, leaf_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -555,7 +555,7 @@ done:
if (hdr->swmr_write && (leaf_flags & H5AC__DIRTIED_FLAG)) {
/* Attempt to shadow the node if doing SWMR writes */
if (H5B2__shadow_leaf(leaf, curr_node_ptr) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTCOPY, FAIL, "unable to shadow leaf B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTCOPY, FAIL, "unable to shadow leaf B-tree node");
/* Change the state to "shadowed" if only modified currently */
/* (Triggers parent to be marked dirty) */
@ -565,7 +565,7 @@ done:
/* Unprotect leaf node */
if (H5AC_unprotect(hdr->f, H5AC_BT2_LEAF, curr_node_ptr->addr, leaf, leaf_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -654,7 +654,7 @@ H5B2__swap_leaf(H5B2_hdr_t *hdr, uint16_t depth, H5B2_internal_t *internal, unsi
done:
/* Unlock child node */
if (child && H5AC_unprotect(hdr->f, child_class, child_addr, child, H5AC__DIRTIED_FLAG) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B2__swap_leaf() */
@ -823,7 +823,7 @@ H5B2__remove_leaf(H5B2_hdr_t *hdr, H5B2_node_ptr_t *curr_node_ptr, H5B2_nodepos_
done:
/* Release the B-tree leaf node */
if (leaf && H5AC_unprotect(hdr->f, H5AC_BT2_LEAF, leaf_addr, leaf, leaf_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__remove_leaf() */
@ -921,7 +921,7 @@ H5B2__remove_leaf_by_idx(H5B2_hdr_t *hdr, H5B2_node_ptr_t *curr_node_ptr, H5B2_n
done:
/* Release the B-tree leaf node */
if (leaf && H5AC_unprotect(hdr->f, H5AC_BT2_LEAF, leaf_addr, leaf, leaf_flags) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5B2__remove_leaf_by_idx() */

2
src/H5B2test.c
View File

@ -568,7 +568,7 @@ done:
if (parent) {
assert(ret_value < 0);
if (parent != hdr && H5AC_unpin_entry(parent) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "unable to unpin parent entry")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPIN, FAIL, "unable to unpin parent entry");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)

2
src/H5Bcache.c
View File

@ -217,7 +217,7 @@ H5B__cache_deserialize(const void *_image, size_t len, void *_udata, hbool_t H5_
done:
if (!ret_value && bt)
if (H5B__node_dest(bt) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, NULL, "unable to destroy B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, NULL, "unable to destroy B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B__cache_deserialize() */

2
src/H5Bdbg.c
View File

@ -124,7 +124,7 @@ H5B_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, const H5
done:
if (bt && H5AC_unprotect(f, H5AC_BT, addr, bt, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5B_debug() */

2
src/H5C.c
View File

@ -542,7 +542,7 @@ done:
* and the cache still exist. JRM -- 5/15/20
*/
if (H5C_set_slist_enabled(f->shared->cache, FALSE, FALSE) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "disable slist on flush dest failure failed")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "disable slist on flush dest failure failed");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_dest() */

4
src/H5CX.c
View File

@ -972,7 +972,7 @@ done:
if (*api_state) {
/* Release the (possibly partially allocated) API state struct */
if (H5CX_free_state(*api_state) < 0)
HDONE_ERROR(H5E_CONTEXT, H5E_CANTRELEASE, FAIL, "unable to release API state")
HDONE_ERROR(H5E_CONTEXT, H5E_CANTRELEASE, FAIL, "unable to release API state");
*api_state = NULL;
} /* end if */
} /* end if */
@ -1095,7 +1095,7 @@ H5CX_free_state(H5CX_state_t *api_state)
HGOTO_ERROR(H5E_CONTEXT, H5E_CANTRELEASE, FAIL, "unable to release VOL connector info object")
/* Decrement connector ID */
if (H5I_dec_ref(api_state->vol_connector_prop.connector_id) < 0)
HDONE_ERROR(H5E_CONTEXT, H5E_CANTDEC, FAIL, "can't close VOL connector ID")
HDONE_ERROR(H5E_CONTEXT, H5E_CANTDEC, FAIL, "can't close VOL connector ID");
} /* end if */
/* Free the state */

28
src/H5Centry.c
View File

@ -1077,7 +1077,7 @@ H5C__load_entry(H5F_t *f,
if (coll_access) {
/* Push an error, but still participate in following MPI_Bcast */
memset(image, 0, len);
HDONE_ERROR(H5E_CACHE, H5E_READERROR, NULL, "Can't read image*")
HDONE_ERROR(H5E_CACHE, H5E_READERROR, NULL, "Can't read image*");
}
else
#endif
@ -1135,7 +1135,7 @@ H5C__load_entry(H5F_t *f,
if (coll_access) {
/* Push an error, but still participate in following MPI_Bcast */
memset(image + len, 0, actual_len - len);
HDONE_ERROR(H5E_CACHE, H5E_CANTLOAD, NULL, "can't read image")
HDONE_ERROR(H5E_CACHE, H5E_CANTLOAD, NULL, "can't read image");
}
else
#endif
@ -1306,7 +1306,7 @@ done:
if (NULL == ret_value) {
/* Release resources */
if (thing && type->free_icr(thing) < 0)
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, NULL, "free_icr callback failed")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, NULL, "free_icr callback failed");
if (image)
image = (uint8_t *)H5MM_xfree(image);
} /* end if */
@ -2068,7 +2068,7 @@ done:
/* Release resources on error */
if (FAIL == ret_value)
if (thing && type->free_icr(thing) < 0)
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "free_icr callback failed")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "free_icr callback failed");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C__deserialize_prefetched_entry() */
@ -2346,12 +2346,12 @@ done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 ||
H5C__validate_lru_list(cache_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit");
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
if (ret_value < 0 && entry_tagged)
if (H5C__untag_entry(cache_ptr, entry_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, "can't remove entry from tag list")
HDONE_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, "can't remove entry from tag list");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_insert_entry() */
@ -2752,7 +2752,7 @@ done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 ||
H5C__validate_lru_list(cache_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit");
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
FUNC_LEAVE_NOAPI(ret_value)
@ -2884,7 +2884,7 @@ H5C_resize_entry(void *thing, size_t new_size)
done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit");
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
FUNC_LEAVE_NOAPI(ret_value)
@ -2933,7 +2933,7 @@ done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 ||
H5C__validate_lru_list(cache_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit");
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
FUNC_LEAVE_NOAPI(ret_value)
@ -3070,7 +3070,7 @@ H5C_protect(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *udata, unsign
/* If image generation fails, push an error but
* still participate in the following MPI_Bcast
*/
HDONE_ERROR(H5E_CACHE, H5E_CANTGET, NULL, "can't generate entry's image")
HDONE_ERROR(H5E_CACHE, H5E_CANTGET, NULL, "can't generate entry's image");
} /* end if */
assert(entry_ptr->image_ptr);
@ -3345,7 +3345,7 @@ done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 ||
H5C__validate_lru_list(cache_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on exit");
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
FUNC_LEAVE_NOAPI(ret_value)
@ -3389,7 +3389,7 @@ done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 ||
H5C__validate_lru_list(cache_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit");
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
FUNC_LEAVE_NOAPI(ret_value)
@ -3684,7 +3684,7 @@ done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 ||
H5C__validate_lru_list(cache_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit");
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
FUNC_LEAVE_NOAPI(ret_value)
@ -4084,7 +4084,7 @@ H5C_expunge_entry(H5F_t *f, const H5C_class_t *type, haddr_t addr, unsigned flag
done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_lru_list(cache_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on exit");
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
FUNC_LEAVE_NOAPI(ret_value)

6
src/H5Cmpio.c
View File

@ -382,7 +382,7 @@ done:
candidate_assignment_table = (unsigned *)H5MM_xfree((void *)candidate_assignment_table);
if (cache_ptr->coll_write_list) {
if (H5SL_close(cache_ptr->coll_write_list) < 0)
HDONE_ERROR(H5E_CACHE, H5E_CANTFREE, FAIL, "failed to destroy skip list")
HDONE_ERROR(H5E_CACHE, H5E_CANTFREE, FAIL, "failed to destroy skip list");
cache_ptr->coll_write_list = NULL;
} /* end if */
@ -798,7 +798,7 @@ done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 ||
H5C__validate_lru_list(cache_ptr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit");
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
FUNC_LEAVE_NOAPI(ret_value)
@ -967,7 +967,7 @@ done:
/* Reset transfer mode in API context, if changed */
if (orig_xfer_mode != H5FD_MPIO_COLLECTIVE)
if (H5CX_set_io_xfer_mode(orig_xfer_mode) < 0)
HDONE_ERROR(H5E_CACHE, H5E_CANTSET, FAIL, "can't set MPI-I/O transfer mode")
HDONE_ERROR(H5E_CACHE, H5E_CANTSET, FAIL, "can't set MPI-I/O transfer mode");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5C__collective_write() */

18
src/H5D.c
View File

@ -141,7 +141,7 @@ H5D__create_api_common(hid_t loc_id, const char *name, hid_t type_id, hid_t spac
done:
if (H5I_INVALID_HID == ret_value)
if (dset && H5VL_dataset_close(*vol_obj_ptr, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__create_api_common() */
@ -229,7 +229,7 @@ H5Dcreate_async(const char *app_file, const char *app_func, unsigned app_line, h
H5ARG_TRACE11(__func__, "*s*sIui*siiiiii", app_file, app_func, app_line, loc_id, name, type_id, space_id, lcpl_id, dcpl_id, dapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref_always_close(ret_value) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on dataset ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on dataset ID");
HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -320,7 +320,7 @@ done:
/* Cleanup on failure */
if (H5I_INVALID_HID == ret_value)
if (dset && H5VL_dataset_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset");
FUNC_LEAVE_API(ret_value)
} /* end H5Dcreate_anon() */
@ -370,7 +370,7 @@ H5D__open_api_common(hid_t loc_id, const char *name, hid_t dapl_id, void **token
done:
if (H5I_INVALID_HID == ret_value)
if (dset && H5VL_dataset_close(*vol_obj_ptr, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5D__open_api_common() */
@ -443,7 +443,7 @@ H5Dopen_async(const char *app_file, const char *app_func, unsigned app_line, hid
H5ARG_TRACE7(__func__, "*s*sIui*sii", app_file, app_func, app_line, loc_id, name, dapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref_always_close(ret_value) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on dataset ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on dataset ID");
HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -540,7 +540,7 @@ H5Dclose_async(const char *app_file, const char *app_func, unsigned app_line, hi
done:
if (connector && H5VL_conn_dec_rc(connector) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "can't decrement ref count on connector")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "can't decrement ref count on connector");
FUNC_LEAVE_API(ret_value)
} /* end H5Dclose_async() */
@ -654,7 +654,7 @@ H5Dget_space_async(const char *app_file, const char *app_func, unsigned app_line
/* clang-format on */
if (H5I_dec_app_ref(ret_value) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, H5I_INVALID_HID,
"can't decrement count on dataspace ID")
"can't decrement count on dataspace ID");
HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -1639,7 +1639,7 @@ H5Dscatter(H5D_scatter_func_t op, void *op_data, hid_t type_id, hid_t dst_space_
done:
/* Release selection iterator */
if (iter_init && H5S_SELECT_ITER_RELEASE(iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't release selection iterator");
if (iter)
iter = H5FL_FREE(H5S_sel_iter_t, iter);
@ -1735,7 +1735,7 @@ H5Dgather(hid_t src_space_id, const void *src_buf, hid_t type_id, size_t dst_buf
done:
/* Release selection iterator */
if (iter_init && H5S_SELECT_ITER_RELEASE(iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't release selection iterator");
if (iter)
iter = H5FL_FREE(H5S_sel_iter_t, iter);

4
src/H5Dbtree.c
View File

@ -1377,9 +1377,9 @@ done:
if (shared_init) {
/* Free the raw B-tree node buffer */
if (NULL == storage.u.btree.shared)
HDONE_ERROR(H5E_IO, H5E_CANTFREE, FAIL, "ref-counted shared info nil")
HDONE_ERROR(H5E_IO, H5E_CANTFREE, FAIL, "ref-counted shared info nil");
else if (H5UC_DEC(storage.u.btree.shared) < 0)
HDONE_ERROR(H5E_IO, H5E_CANTFREE, FAIL, "unable to decrement ref-counted shared info")
HDONE_ERROR(H5E_IO, H5E_CANTFREE, FAIL, "unable to decrement ref-counted shared info");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)

4
src/H5Dbtree2.c
View File

@ -623,7 +623,7 @@ H5D__btree2_idx_depend(const H5D_chk_idx_info_t *idx_info)
done:
/* Release the object header from the cache */
if (oh && H5O_unprotect(&oloc, oh, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPROTECT, FAIL, "unable to release object header")
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPROTECT, FAIL, "unable to release object header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__btree2_idx_depend() */
@ -1360,7 +1360,7 @@ H5D__bt2_idx_size(const H5D_chk_idx_info_t *idx_info, hsize_t *index_size)
done:
/* Close v2 B-tree index */
if (bt2_cdset && H5B2_close(bt2_cdset) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for tracking chunked dataset")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for tracking chunked dataset");
idx_info->storage->u.btree2.bt2 = NULL;
FUNC_LEAVE_NOAPI(ret_value)

54
src/H5Dchunk.c
View File

@ -1108,7 +1108,7 @@ H5D__chunk_io_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo)
done:
if (file_space_normalized == TRUE)
if (H5S_hyper_denormalize_offset(dinfo->file_space, old_offset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't denormalize selection")
HDONE_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't denormalize selection");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__chunk_io_init() */
@ -1312,15 +1312,15 @@ done:
if (tmp_mspace && !fm->mchunk_tmpl)
if (H5S_close(tmp_mspace) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL,
"can't release memory chunk dataspace template")
"can't release memory chunk dataspace template");
if (H5D__chunk_io_term(io_info, dinfo) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release chunk mapping")
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release chunk mapping");
} /* end if */
if (iter_init && H5S_SELECT_ITER_RELEASE(&(fm->mem_iter)) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator");
if (file_type && (H5T_close_real(file_type) < 0))
HDONE_ERROR(H5E_DATATYPE, H5E_CANTFREE, FAIL, "Can't free temporary datatype")
HDONE_ERROR(H5E_DATATYPE, H5E_CANTFREE, FAIL, "Can't free temporary datatype");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__chunk_io_init_selections() */
@ -1759,7 +1759,7 @@ H5D__create_piece_file_map_all(H5D_dset_io_info_t *di, H5D_io_info_t *io_info)
done:
/* Clean up */
if (tmp_fchunk && H5S_close(tmp_fchunk) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "can't release temporary dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "can't release temporary dataspace");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__create_chunk_file_map_all() */
@ -1938,7 +1938,7 @@ done:
/* Clean up on failure */
if (ret_value < 0)
if (tmp_fchunk && H5S_close(tmp_fchunk) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "can't release temporary dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "can't release temporary dataspace");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__create_piece_file_map_hyper() */
@ -3417,7 +3417,7 @@ H5D__chunk_dest(H5D_t *dset)
/* Continue even if there are failures. */
if (nerrors)
HDONE_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks")
HDONE_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
/* Release cache structures */
if (rdcc->slot)
@ -4023,7 +4023,7 @@ H5D__chunk_cache_evict(const H5D_t *dset, H5D_rdcc_ent_t *ent, hbool_t flush)
if (flush) {
/* Flush */
if (H5D__chunk_flush_entry(dset, ent, TRUE) < 0)
HDONE_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "cannot flush indexed storage buffer")
HDONE_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "cannot flush indexed storage buffer");
} /* end if */
else {
/* Don't flush, just free chunk */
@ -4577,7 +4577,7 @@ H5D__chunk_lock(const H5D_io_info_t H5_ATTR_NDEBUG_UNUSED *io_info, const H5D_ds
done:
/* Release the fill buffer info, if it's been initialized */
if (fb_info_init && H5D__fill_term(&fb_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, NULL, "Can't release fill buffer info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, NULL, "Can't release fill buffer info");
/* Release the chunk allocated, on error */
if (!ret_value)
@ -5229,7 +5229,7 @@ H5D__chunk_allocate(const H5D_t *dset, hbool_t full_overwrite, const hsize_t old
done:
/* Release the fill buffer info, if it's been initialized */
if (fb_info_init && H5D__fill_term(&fb_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");
/* Free the unfiltered fill value buffer */
unfilt_fill_buf = H5D__chunk_mem_xfree(unfilt_fill_buf, &def_pline);
@ -5663,7 +5663,7 @@ done:
if (have_xfer_mode)
/* Set transfer mode */
if (H5CX_set_io_xfer_mode(prev_xfer_mode) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set transfer mode")
HDONE_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set transfer mode");
/* free things */
if (MPI_BYTE != file_type)
@ -5806,7 +5806,7 @@ H5D__chunk_prune_fill(H5D_chunk_it_ud1_t *udata, hbool_t new_unfilt_chunk)
done:
/* Release the selection iterator */
if (chunk_iter_init && H5S_SELECT_ITER_RELEASE(chunk_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (chunk_iter)
chunk_iter = H5FL_FREE(H5S_sel_iter_t, chunk_iter);
@ -6237,10 +6237,10 @@ H5D__chunk_prune_by_extent(H5D_t *dset, const hsize_t *old_dim)
done:
/* Release resources */
if (chunk_space && H5S_close(chunk_space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataspace");
if (udata_init)
if (udata.fb_info_init && H5D__fill_term(&udata.fb_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__chunk_prune_by_extent() */
@ -6387,10 +6387,10 @@ done:
/* Clean up any messages read in */
if (pline_read)
if (H5O_msg_reset(H5O_PLINE_ID, &pline) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset I/O pipeline message")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset I/O pipeline message");
if (layout_read)
if (H5O_msg_reset(H5O_LAYOUT_ID, &layout) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset layout message")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset layout message");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__chunk_delete() */
@ -6740,7 +6740,7 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
if (need_insert && udata->idx_info_dst->storage->ops->insert)
if ((udata->idx_info_dst->storage->ops->insert)(udata->idx_info_dst, &udata_dst, NULL) < 0)
HGOTO_ERROR_TAG(H5E_DATASET, H5E_CANTINSERT, H5_ITER_ERROR,
"unable to insert chunk addr into index")
"unable to insert chunk addr into index");
/* Reset metadata tag in API context */
H5_END_TAG
@ -7006,13 +7006,13 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src, H5O_layout_chunk
done:
if (sid_buf > 0 && H5I_dec_ref(sid_buf) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't decrement temporary dataspace ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't decrement temporary dataspace ID");
if (tid_src > 0 && H5I_dec_ref(tid_src) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (tid_dst > 0 && H5I_dec_ref(tid_dst) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (tid_mem > 0 && H5I_dec_ref(tid_mem) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (buf)
H5MM_xfree(buf);
if (bkg)
@ -7024,7 +7024,7 @@ done:
if (copy_setup_done)
if (storage_src->ops->copy_shutdown &&
(storage_src->ops->copy_shutdown)(storage_src, storage_dst) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to shut down index copying info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to shut down index copying info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__chunk_copy() */
@ -7094,11 +7094,11 @@ H5D__chunk_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5O_layout_t *layout, hsize_
done:
/* Free resources, if they've been initialized */
if (idx_info_init && sc->ops->dest && (sc->ops->dest)(&idx_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to release chunk index info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to release chunk index info");
if (pline_read && H5O_msg_reset(H5O_PLINE_ID, &pline) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset I/O pipeline message")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset I/O pipeline message");
if (space && H5S_close(space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataspace");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__chunk_bh_info() */
@ -7302,7 +7302,7 @@ H5D__nonexistent_readvv_cb(hsize_t H5_ATTR_UNUSED dst_off, hsize_t src_off, size
done:
/* Release the fill buffer info, if it's been initialized */
if (fb_info_init && H5D__fill_term(&fb_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5D__nonexistent_readvv_cb() */

10
src/H5Dcompact.c
View File

@ -141,7 +141,7 @@ H5D__compact_fill(const H5D_t *dset)
done:
/* Release the fill buffer info, if it's been initialized */
if (fb_info_init && H5D__fill_term(&fb_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__compact_fill() */
@ -628,13 +628,13 @@ H5D__compact_copy(H5F_t *f_src, H5O_storage_compact_t *_storage_src, H5F_t *f_ds
done:
if (buf_sid > 0 && H5I_dec_ref(buf_sid) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't decrement temporary dataspace ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't decrement temporary dataspace ID");
if (tid_src > 0 && H5I_dec_ref(tid_src) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (tid_dst > 0 && H5I_dec_ref(tid_dst) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (tid_mem > 0 && H5I_dec_ref(tid_mem) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (buf)
buf = H5FL_BLK_FREE(type_conv, buf);
if (reclaim_buf)

16
src/H5Dcontig.c
View File

@ -288,7 +288,7 @@ H5D__contig_fill(H5D_t *dset)
* still participate in following MPI_Barrier.
*/
blocks_written = TRUE;
HDONE_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset")
HDONE_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset");
break;
}
}
@ -325,7 +325,7 @@ H5D__contig_fill(H5D_t *dset)
done:
/* Release the fill buffer info, if it's been initialized */
if (fb_info_init && H5D__fill_term(&fb_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__contig_fill() */
@ -667,13 +667,13 @@ H5D__contig_io_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo)
done:
if (ret_value < 0) {
if (H5D__contig_io_term(io_info, dinfo) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release dataset I/O info")
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release dataset I/O info");
} /* end if */
if (file_space_normalized) {
/* (Casting away const OK -QAK) */
if (H5S_hyper_denormalize_offset(dinfo->file_space, old_offset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_BADSELECT, FAIL, "unable to normalize dataspace by offset")
HDONE_ERROR(H5E_DATASET, H5E_BADSELECT, FAIL, "unable to normalize dataspace by offset");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -1835,13 +1835,13 @@ H5D__contig_copy(H5F_t *f_src, const H5O_storage_contig_t *storage_src, H5F_t *f
done:
if (buf_sid > 0 && H5I_dec_ref(buf_sid) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't decrement temporary dataspace ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't decrement temporary dataspace ID");
if (tid_src > 0 && H5I_dec_ref(tid_src) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (tid_dst > 0 && H5I_dec_ref(tid_dst) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (tid_mem > 0 && H5I_dec_ref(tid_mem) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (buf)
buf = H5FL_BLK_FREE(type_conv, buf);
if (reclaim_buf)

6
src/H5Ddeprec.c
View File

@ -144,7 +144,7 @@ H5Dcreate1(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id, hid_t
done:
if (H5I_INVALID_HID == ret_value)
if (dset && H5VL_dataset_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset");
FUNC_LEAVE_API(ret_value)
} /* end H5Dcreate1() */
@ -200,7 +200,7 @@ H5Dopen1(hid_t loc_id, const char *name)
done:
if (H5I_INVALID_HID == ret_value)
if (dset && H5VL_dataset_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset");
FUNC_LEAVE_API(ret_value)
} /* end H5Dopen1() */
@ -286,7 +286,7 @@ H5Dextend(hid_t dset_id, const hsize_t size[])
done:
/* Close the dataspace */
if (sid != H5I_INVALID_HID && H5I_dec_app_ref(sid) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close dataspace");
FUNC_LEAVE_API(ret_value)
} /* end H5Dextend() */

4
src/H5Dearray.c
View File

@ -612,7 +612,7 @@ done:
/* Close object header */
if (obj_opened)
if (H5O_close(&obj_loc, NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, NULL, "can't close object header")
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, NULL, "can't close object header");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -700,7 +700,7 @@ H5D__earray_idx_depend(const H5D_chk_idx_info_t *idx_info)
done:
/* Release the object header from the cache */
if (oh && H5O_unprotect(&oloc, oh, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPROTECT, FAIL, "unable to release object header")
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPROTECT, FAIL, "unable to release object header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__earray_idx_depend() */

4
src/H5Dfarray.c
View File

@ -464,7 +464,7 @@ done:
/* Close object header */
if (obj_opened)
if (H5O_close(&obj_loc, NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, NULL, "can't close object header")
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, NULL, "can't close object header");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -696,7 +696,7 @@ H5D__farray_idx_depend(const H5D_chk_idx_info_t *idx_info)
done:
/* Release the object header from the cache */
if (oh && H5O_unprotect(&oloc, oh, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPROTECT, FAIL, "unable to release object header")
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPROTECT, FAIL, "unable to release object header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__farray_idx_depend() */

16
src/H5Dfill.c
View File

@ -269,19 +269,19 @@ H5D__fill(const void *fill, const H5T_t *fill_type, void *buf, const H5T_t *buf_
done:
if (mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
if (src_id != (-1) && H5I_dec_ref(src_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (dst_id != (-1) && H5I_dec_ref(dst_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID");
if (tmp_buf)
tmp_buf = H5FL_BLK_FREE(type_conv, tmp_buf);
if (elem_wb && H5WB_unwrap(elem_wb) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer");
if (bkg_elem_wb && H5WB_unwrap(bkg_elem_wb) < 0)
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer")
HDONE_ERROR(H5E_ATTR, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer");
if (bkg_buf)
bkg_buf = H5FL_BLK_FREE(type_conv, bkg_buf);
@ -480,7 +480,7 @@ done:
/* Cleanup on error */
if (ret_value < 0)
if (H5D__fill_term(fb_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__fill_init() */
@ -548,11 +548,11 @@ done:
/* Free dynamically allocated VL elements in fill buffer */
if (fb_info->fill->type) {
if (H5T_vlen_reclaim_elmt(buf, fb_info->fill->type) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't reclaim vlen element")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't reclaim vlen element");
} /* end if */
else {
if (H5T_vlen_reclaim_elmt(buf, fb_info->mem_type) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't reclaim vlen element")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't reclaim vlen element");
} /* end else */
/* Free temporary fill buffer */

106
src/H5Dint.c
View File

@ -468,9 +468,9 @@ done:
if (ret_value == NULL)
if (new_dset != NULL) {
if (new_dset->dcpl_id != 0 && H5I_dec_ref(new_dset->dcpl_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL, "can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL, "can't decrement temporary datatype ID");
if (new_dset->dapl_id != 0 && H5I_dec_ref(new_dset->dapl_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL, "can't decrement temporary datatype ID")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL, "can't decrement temporary datatype ID");
new_dset = H5FL_FREE(H5D_shared_t, new_dset);
} /* end if */
@ -1022,14 +1022,14 @@ done:
/* Release pointer to object header itself */
if (oh != NULL)
if (H5O_unpin(oh) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPIN, FAIL, "unable to unpin dataset object header")
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPIN, FAIL, "unable to unpin dataset object header");
/* Error cleanup */
if (ret_value < 0)
if (layout_init)
/* Destroy the layout information for the dataset */
if (dset->shared->layout.ops->dest && (dset->shared->layout.ops->dest)(dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to destroy layout info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to destroy layout info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__update_oh_info() */
@ -1329,48 +1329,48 @@ done:
if (new_dset->shared) {
if (layout_init)
if (new_dset->shared->layout.ops->dest && (new_dset->shared->layout.ops->dest)(new_dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, NULL, "unable to destroy layout info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, NULL, "unable to destroy layout info");
if (pline_copied)
if (H5O_msg_reset(H5O_PLINE_ID, &new_dset->shared->dcpl_cache.pline) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, NULL, "unable to reset I/O pipeline info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, NULL, "unable to reset I/O pipeline info");
if (layout_copied)
if (H5O_msg_reset(H5O_LAYOUT_ID, &new_dset->shared->layout) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, NULL, "unable to reset layout info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, NULL, "unable to reset layout info");
if (fill_copied)
if (H5O_msg_reset(H5O_FILL_ID, &new_dset->shared->dcpl_cache.fill) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, NULL, "unable to reset fill-value info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, NULL, "unable to reset fill-value info");
if (efl_copied)
if (H5O_msg_reset(H5O_EFL_ID, &new_dset->shared->dcpl_cache.efl) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, NULL, "unable to reset external file list info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, NULL, "unable to reset external file list info");
if (new_dset->shared->space && H5S_close(new_dset->shared->space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release dataspace");
if (new_dset->shared->type) {
if (new_dset->shared->type_id > 0) {
if (H5I_dec_ref(new_dset->shared->type_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release datatype")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release datatype");
} /* end if */
else {
if (H5T_close_real(new_dset->shared->type) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release datatype")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release datatype");
} /* end else */
} /* end if */
if (H5_addr_defined(new_dset->oloc.addr)) {
if (H5O_dec_rc_by_loc(&(new_dset->oloc)) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL,
"unable to decrement refcount on newly created object")
"unable to decrement refcount on newly created object");
if (H5O_close(&(new_dset->oloc), NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release object header")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release object header");
if (file) {
if (H5O_delete(file, new_dset->oloc.addr) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDELETE, NULL, "unable to delete object header")
HDONE_ERROR(H5E_DATASET, H5E_CANTDELETE, NULL, "unable to delete object header");
} /* end if */
} /* end if */
if (new_dset->shared->dcpl_id != 0 && H5I_dec_ref(new_dset->shared->dcpl_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL, "unable to decrement ref count on property list")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL, "unable to decrement ref count on property list");
if (new_dset->shared->dapl_id != 0 && H5I_dec_ref(new_dset->shared->dapl_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL, "unable to decrement ref count on property list")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL, "unable to decrement ref count on property list");
new_dset->shared->extfile_prefix = (char *)H5MM_xfree(new_dset->shared->extfile_prefix);
new_dset->shared->vds_prefix = (char *)H5MM_xfree(new_dset->shared->vds_prefix);
new_dset->shared = H5FL_FREE(H5D_shared_t, new_dset->shared);
@ -1434,7 +1434,7 @@ H5D__open_name(const H5G_loc_t *loc, const char *name, hid_t dapl_id)
done:
if (!ret_value)
if (loc_found && H5G_loc_free(&dset_loc) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, NULL, "can't free location")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, NULL, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__open_name() */
@ -1821,21 +1821,21 @@ H5D__open_oid(H5D_t *dataset, hid_t dapl_id)
done:
if (ret_value < 0) {
if (H5_addr_defined(dataset->oloc.addr) && H5O_close(&(dataset->oloc), NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release object header")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release object header");
if (dataset->shared) {
if (layout_init)
if (dataset->shared->layout.ops->dest && (dataset->shared->layout.ops->dest)(dataset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to destroy layout info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to destroy layout info");
if (dataset->shared->space && H5S_close(dataset->shared->space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataspace");
if (dataset->shared->type) {
if (dataset->shared->type_id > 0) {
if (H5I_dec_ref(dataset->shared->type_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release datatype")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release datatype");
} /* end if */
else {
if (H5T_close_real(dataset->shared->type) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release datatype")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release datatype");
} /* end else */
} /* end if */
} /* end if */
@ -1878,7 +1878,7 @@ H5D_close(H5D_t *dataset)
/* Flush the dataset's information. Continue to close even if it fails. */
if (H5D__flush_real(dataset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to flush cached dataset info")
HDONE_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to flush cached dataset info");
/* Set a flag to indicate the dataset is closing, before we start freeing things */
/* (Avoids problems with flushing datasets twice, when one is holding
@ -1933,7 +1933,7 @@ H5D_close(H5D_t *dataset)
if (dataset->shared->layout.storage.u.virt.list[i].source_dset.dset) {
assert(dataset->shared->layout.storage.u.virt.list[i].source_dset.dset != dataset);
if (H5D_close(dataset->shared->layout.storage.u.virt.list[i].source_dset.dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to close source dataset")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to close source dataset");
dataset->shared->layout.storage.u.virt.list[i].source_dset.dset = NULL;
} /* end if */
@ -1945,7 +1945,7 @@ H5D_close(H5D_t *dataset)
if (H5D_close(dataset->shared->layout.storage.u.virt.list[i].sub_dset[j].dset) <
0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL,
"unable to close source dataset")
"unable to close source dataset");
dataset->shared->layout.storage.u.virt.list[i].sub_dset[j].dset = NULL;
} /* end if */
} /* end for */
@ -1963,7 +1963,7 @@ H5D_close(H5D_t *dataset)
/* Destroy any cached layout information for the dataset */
if (dataset->shared->layout.ops->dest && (dataset->shared->layout.ops->dest)(dataset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to destroy layout info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to destroy layout info");
/* Free the external file prefix */
dataset->shared->extfile_prefix = (char *)H5MM_xfree(dataset->shared->extfile_prefix);
@ -1980,10 +1980,10 @@ H5D_close(H5D_t *dataset)
/* Uncork cache entries with object address tag */
if (H5AC_cork(dataset->oloc.file, dataset->oloc.addr, H5AC__GET_CORKED, &corked) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve an object's cork status")
HDONE_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve an object's cork status");
if (corked)
if (H5AC_cork(dataset->oloc.file, dataset->oloc.addr, H5AC__UNCORK, NULL) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTUNCORK, FAIL, "unable to uncork an object")
HDONE_ERROR(H5E_DATASET, H5E_CANTUNCORK, FAIL, "unable to uncork an object");
/* Release datatype, dataspace, and creation and access property lists -- there isn't
* much we can do if one of these fails, so we just continue.
@ -1994,21 +1994,21 @@ H5D_close(H5D_t *dataset)
/* Remove the dataset from the list of opened objects in the file */
if (H5FO_top_decr(dataset->oloc.file, dataset->oloc.addr) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "can't decrement count for object")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "can't decrement count for object");
if (H5FO_delete(dataset->oloc.file, dataset->oloc.addr) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "can't remove dataset from list of open objects")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "can't remove dataset from list of open objects");
/* Close the dataset object */
/* (This closes the file, if this is the last object open) */
if (H5O_close(&(dataset->oloc), &file_closed) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release object header")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release object header");
/* Evict dataset metadata if evicting on close */
if (!file_closed && H5F_SHARED(dataset->oloc.file) && H5F_EVICT_ON_CLOSE(dataset->oloc.file)) {
if (H5AC_flush_tagged_metadata(dataset->oloc.file, dataset->oloc.addr) < 0)
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush tagged metadata")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush tagged metadata");
if (H5AC_evict_tagged_metadata(dataset->oloc.file, dataset->oloc.addr, FALSE) < 0)
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to evict tagged metadata")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to evict tagged metadata");
} /* end if */
/*
@ -2726,9 +2726,9 @@ H5D__vlen_get_buf_size(H5D_t *dset, hid_t type_id, hid_t space_id, hsize_t *size
done:
if (fspace && H5S_close(fspace) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release dataspace")
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release dataspace");
if (mspace && H5S_close(mspace) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release dataspace")
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release dataspace");
if (vlen_bufsize.common.fl_tbuf != NULL)
vlen_bufsize.common.fl_tbuf = H5FL_BLK_FREE(vlen_fl_buf, vlen_bufsize.common.fl_tbuf);
if (vlen_bufsize.common.vl_tbuf != NULL)
@ -2883,29 +2883,29 @@ H5D__vlen_get_buf_size_gen(H5VL_object_t *vol_obj, hid_t type_id, hid_t space_id
done:
if (vlen_bufsize.fspace_id >= 0) {
if (H5I_dec_app_ref(vlen_bufsize.fspace_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "problem freeing id")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "problem freeing id");
vlen_bufsize.fspace = NULL;
} /* end if */
if (vlen_bufsize.fspace && H5S_close(vlen_bufsize.fspace) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release dataspace");
if (vlen_bufsize.mspace_id >= 0) {
if (H5I_dec_app_ref(vlen_bufsize.mspace_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "problem freeing id")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "problem freeing id");
mspace = NULL;
} /* end if */
if (mspace && H5S_close(mspace) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release dataspace");
if (vlen_bufsize.common.fl_tbuf != NULL)
vlen_bufsize.common.fl_tbuf = H5FL_BLK_FREE(vlen_fl_buf, vlen_bufsize.common.fl_tbuf);
if (vlen_bufsize.common.vl_tbuf != NULL)
vlen_bufsize.common.vl_tbuf = H5FL_BLK_FREE(vlen_vl_buf, vlen_bufsize.common.vl_tbuf);
if (vlen_bufsize.dxpl_id != H5I_INVALID_HID) {
if (H5I_dec_app_ref(vlen_bufsize.dxpl_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "can't close property list")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "can't close property list");
dxpl = NULL;
} /* end if */
if (dxpl && H5P_close(dxpl) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release DXPL")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release DXPL");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__vlen_get_buf_size_gen() */
@ -3374,30 +3374,30 @@ done:
/* Remove new layout message */
if (add_new_layout)
if (H5O_msg_remove(&dataset->oloc, H5O_LAYOUT_ID, H5O_ALL, FALSE) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTDELETE, FAIL, "unable to delete layout message")
HDONE_ERROR(H5E_SYM, H5E_CANTDELETE, FAIL, "unable to delete layout message");
/* Add back old layout message */
if (delete_old_layout)
if (H5O_msg_create(&dataset->oloc, H5O_LAYOUT_ID, 0, H5O_UPDATE_TIME, &dataset->shared->layout) <
0)
HDONE_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to add layout header message")
HDONE_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to add layout header message");
/* Clean up v1 b-tree chunk index */
if (init_new_index) {
if (H5_addr_defined(new_idx_info.storage->idx_addr)) {
/* Check for valid address i.e. tag */
if (!H5_addr_defined(dataset->oloc.addr))
HDONE_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "address undefined")
HDONE_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "address undefined");
/* Expunge from cache all v1 B-tree type entries associated with tag */
if (H5AC_expunge_tag_type_metadata(dataset->oloc.file, dataset->oloc.addr, H5AC_BT_ID,
H5AC__NO_FLAGS_SET))
HDONE_ERROR(H5E_DATASET, H5E_CANTEXPUNGE, FAIL, "unable to expunge index metadata")
HDONE_ERROR(H5E_DATASET, H5E_CANTEXPUNGE, FAIL, "unable to expunge index metadata");
} /* end if */
/* Delete v1 B-tree chunk index */
if (new_idx_info.storage->ops->dest && (new_idx_info.storage->ops->dest)(&new_idx_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to release chunk index info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to release chunk index info");
} /* end if */
} /* end if */
@ -3462,7 +3462,7 @@ done:
/* Release pointer to object header */
if (oh != NULL)
if (H5O_unpin(oh) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPIN, FAIL, "unable to unpin dataset object header")
HDONE_ERROR(H5E_DATASET, H5E_CANTUNPIN, FAIL, "unable to unpin dataset object header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__mark() */
@ -3700,7 +3700,7 @@ done:
if (ret_value < 0)
if (new_dcpl_id > 0)
if (H5I_dec_app_ref(new_dcpl_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "unable to close temporary object")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "unable to close temporary object");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D_get_create_plist() */
@ -3821,7 +3821,7 @@ done:
if (ret_value < 0)
if (new_dapl_id > 0)
if (H5I_dec_app_ref(new_dapl_id) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, FAIL, "can't free")
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, FAIL, "can't free");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D_get_access_plist() */
@ -3860,7 +3860,7 @@ done:
if (ret_value < 0)
if (space != NULL)
if (H5S_close(space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataspace");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__get_space() */
@ -3914,7 +3914,7 @@ H5D__get_type(const H5D_t *dset)
done:
if (ret_value < 0)
if (dt && H5T_close(dt) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release datatype")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release datatype");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__get_type() */
@ -3960,7 +3960,7 @@ done:
/* Release hold on (source) virtual datasets' files */
if (virt_dsets_held)
if (H5D__virtual_release_source_dset_files(head) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "can't release VDS source files held open")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "can't release VDS source files held open");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__refresh() */

12
src/H5Dio.c
View File

@ -424,11 +424,11 @@ done:
for (i = 0; i < io_op_init; i++)
if (!dset_info[i].skip_io && dset_info[i].layout_ops.io_term &&
(*dset_info[i].layout_ops.io_term)(&io_info, &(dset_info[i])) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down I/O op info")
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down I/O op info");
/* Shut down datatype info for operation */
if (H5D__typeinfo_term(&io_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down type info")
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down type info");
/* Discard projected mem spaces and restore originals */
if (orig_mem_space) {
@ -436,7 +436,7 @@ done:
if (orig_mem_space[i]) {
if (H5S_close(dset_info[i].mem_space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL,
"unable to shut down projected memory dataspace")
"unable to shut down projected memory dataspace");
dset_info[i].mem_space = orig_mem_space[i];
}
@ -833,12 +833,12 @@ done:
assert(!dset_info[i].skip_io);
if (dset_info[i].layout_ops.io_term &&
(*dset_info[i].layout_ops.io_term)(&io_info, &(dset_info[i])) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down I/O op info")
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down I/O op info");
}
/* Shut down datatype info for operation */
if (H5D__typeinfo_term(&io_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down type info")
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down type info");
/* Discard projected mem spaces and restore originals */
if (orig_mem_space) {
@ -846,7 +846,7 @@ done:
if (orig_mem_space[i]) {
if (H5S_close(dset_info[i].mem_space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL,
"unable to shut down projected memory dataspace")
"unable to shut down projected memory dataspace");
dset_info[i].mem_space = orig_mem_space[i];
}

8
src/H5Dlayout.c
View File

@ -552,7 +552,7 @@ done:
if (layout_init)
/* Destroy any cached layout information for the dataset */
if (dset->shared->layout.ops->dest && (dset->shared->layout.ops->dest)(dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to destroy layout info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to destroy layout info");
FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5D__layout_oh_create() */
@ -647,13 +647,13 @@ done:
if (ret_value < 0) {
if (pline_copied)
if (H5O_msg_reset(H5O_PLINE_ID, &dataset->shared->dcpl_cache.pline) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset pipeline info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset pipeline info");
if (layout_copied)
if (H5O_msg_reset(H5O_LAYOUT_ID, &dataset->shared->layout) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset layout info")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset layout info");
if (efl_copied)
if (H5O_msg_reset(H5O_EFL_ID, &dataset->shared->dcpl_cache.efl) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset efl message")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset efl message");
}
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__layout_oh_read() */

28
src/H5Dmpio.c
View File

@ -1319,7 +1319,7 @@ done:
if (debug_log_file) {
fprintf(debug_log_file, "##############\n\n");
if (EOF == fclose(debug_log_file))
HDONE_ERROR(H5E_IO, H5E_CLOSEERROR, FAIL, "couldn't close debugging log file")
HDONE_ERROR(H5E_IO, H5E_CLOSEERROR, FAIL, "couldn't close debugging log file");
debug_stream = H5DEBUG(D);
}
#endif
@ -2127,7 +2127,7 @@ H5D__multi_chunk_collective_io(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_
done:
/* Reset collective opt mode */
if (H5CX_set_mpio_coll_opt(orig_coll_opt_mode) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't reset MPI-I/O collective_op property")
HDONE_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't reset MPI-I/O collective_op property");
/* Free memory */
if (chunk_io_option)
@ -3409,7 +3409,7 @@ H5D__mpio_redistribute_shared_chunks_int(H5D_filtered_collective_io_info_t *chun
if (NULL == (counts_disps_array = H5MM_malloc(2 * (size_t)mpi_size * sizeof(*counts_disps_array)))) {
/* Push an error, but still participate in collective gather operation */
HDONE_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL,
"couldn't allocate receive counts and displacements array")
"couldn't allocate receive counts and displacements array");
}
else {
/* Set the receive counts from the assigned chunks map */
@ -4067,7 +4067,7 @@ done:
if (mem_iter) {
if (mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "couldn't release dataspace selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "couldn't release dataspace selection iterator");
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
}
@ -4288,7 +4288,7 @@ H5D__mpio_collective_filtered_chunk_read(H5D_filtered_collective_io_info_t *chun
if (NULL == (chunk_list[i].buf = H5MM_malloc(chunk_list[i].chunk_buf_size))) {
/* Push an error, but participate in collective read */
HDONE_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate chunk data buffer")
HDONE_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate chunk data buffer");
break;
}
@ -4407,9 +4407,9 @@ done:
/* Release the fill buffer info, if it's been initialized */
if (fb_info_init && H5D__fill_term(&fb_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");
if (fill_space && (H5S_close(fill_space) < 0))
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close fill space")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close fill space");
#ifdef H5Dmpio_DEBUG
H5D_MPIO_TIME_STOP(mpi_rank);
@ -4526,7 +4526,7 @@ H5D__mpio_collective_filtered_chunk_update(H5D_filtered_collective_io_info_t *ch
if (NULL == chunk_list[i].buf) {
/* Push an error, but participate in collective read */
HDONE_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate chunk data buffer")
HDONE_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate chunk data buffer");
break;
}
@ -4738,17 +4738,17 @@ H5D__mpio_collective_filtered_chunk_update(H5D_filtered_collective_io_info_t *ch
done:
if (sel_iter) {
if (sel_iter_init && H5S_SELECT_ITER_RELEASE(sel_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "couldn't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "couldn't release selection iterator");
sel_iter = H5FL_FREE(H5S_sel_iter_t, sel_iter);
}
if (dataspace && (H5S_close(dataspace) < 0))
HDONE_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "can't close dataspace")
HDONE_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "can't close dataspace");
if (fill_space && (H5S_close(fill_space) < 0))
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close fill space")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close fill space");
/* Release the fill buffer info, if it's been initialized */
if (fb_info_init && H5D__fill_term(&fb_info) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");
/* On failure, try to free all resources used by entries in the chunk list */
if (ret_value < 0) {
@ -4841,7 +4841,7 @@ H5D__mpio_collective_filtered_chunk_reallocate(H5D_filtered_collective_io_info_t
if (NULL == (counts_disps_array = H5MM_malloc(2 * (size_t)mpi_size * sizeof(*counts_disps_array)))) {
/* Push an error, but still participate in collective gather operation */
HDONE_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL,
"couldn't allocate receive counts and displacements array")
"couldn't allocate receive counts and displacements array");
}
else {
/* Set the receive counts from the assigned chunks map */
@ -5035,7 +5035,7 @@ H5D__mpio_collective_filtered_chunk_reinsert(H5D_filtered_collective_io_info_t *
if (NULL == (counts_disps_array = H5MM_malloc(2 * (size_t)mpi_size * sizeof(*counts_disps_array)))) {
/* Push an error, but still participate in collective gather operation */
HDONE_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL,
"couldn't allocate receive counts and displacements array")
"couldn't allocate receive counts and displacements array");
}
else {
/* Set the receive counts from the assigned chunks map */

10
src/H5Doh.c
View File

@ -238,7 +238,7 @@ H5O__dset_open(const H5G_loc_t *obj_loc, H5I_type_t *opened_type)
done:
if (NULL == ret_value)
if (dset && H5D_close(dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release dataset")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release dataset");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O__dset_open() */
@ -284,7 +284,7 @@ H5O__dset_create(H5F_t *f, void *_crt_info, H5G_loc_t *obj_loc)
done:
if (ret_value == NULL)
if (dset && H5D_close(dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release dataset")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release dataset");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O__dset_create() */
@ -393,9 +393,9 @@ H5O__dset_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5_ih_info_t *bh_info)
done:
/* Free messages, if they've been read in */
if (layout_read && H5O_msg_reset(H5O_LAYOUT_ID, &layout) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset data storage layout message")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset data storage layout message");
if (efl_read && H5O_msg_reset(H5O_EFL_ID, &efl) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset external file list message")
HDONE_ERROR(H5E_DATASET, H5E_CANTRESET, FAIL, "unable to reset external file list message");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O__dset_bh_info() */
@ -429,7 +429,7 @@ H5O__dset_flush(void *_obj_ptr)
HGOTO_ERROR(H5E_DATASET, H5E_BADTYPE, FAIL, "not a dataset")
if (H5D__flush_real(dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to flush cached dataset info")
HDONE_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to flush cached dataset info");
done:
FUNC_LEAVE_NOAPI(ret_value)

20
src/H5Dscatgath.c
View File

@ -554,15 +554,15 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_
done:
/* Release selection iterators */
if (file_iter_init && H5S_SELECT_ITER_RELEASE(file_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (file_iter)
file_iter = H5FL_FREE(H5S_sel_iter_t, file_iter);
if (mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
if (bkg_iter_init && H5S_SELECT_ITER_RELEASE(bkg_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (bkg_iter)
bkg_iter = H5FL_FREE(H5S_sel_iter_t, bkg_iter);
@ -697,15 +697,15 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset
done:
/* Release selection iterators */
if (file_iter_init && H5S_SELECT_ITER_RELEASE(file_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (file_iter)
file_iter = H5FL_FREE(H5S_sel_iter_t, file_iter);
if (mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
if (bkg_iter_init && H5S_SELECT_ITER_RELEASE(bkg_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (bkg_iter)
bkg_iter = H5FL_FREE(H5S_sel_iter_t, bkg_iter);
@ -922,7 +922,7 @@ H5D__scatgath_read_select(H5D_io_info_t *io_info)
done:
/* Release and free selection iterator */
if (mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
@ -935,7 +935,7 @@ done:
for (i = 0; i < io_info->pieces_added; i++)
if (tmp_mem_spaces[i] != io_info->mem_spaces[i] && tmp_mem_spaces[i] &&
H5S_close(tmp_mem_spaces[i]) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "Can't close dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "Can't close dataspace");
H5MM_free(tmp_mem_spaces);
tmp_mem_spaces = NULL;
}
@ -1231,7 +1231,7 @@ H5D__scatgath_write_select(H5D_io_info_t *io_info)
done:
/* Release and free selection iterator */
if (mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator");
if (mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
@ -1244,7 +1244,7 @@ done:
for (i = 0; i < spaces_added; i++) {
assert(write_mem_spaces[i]);
if (write_mem_spaces[i] != io_info->mem_spaces[i] && H5S_close(write_mem_spaces[i]) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "Can't close dataspace")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "Can't close dataspace");
}
H5MM_free(write_mem_spaces);
write_mem_spaces = NULL;

8
src/H5Dselect.c
View File

@ -235,11 +235,11 @@ H5D__select_io(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_info
done:
/* Release selection iterators */
if (file_iter_init && H5S_SELECT_ITER_RELEASE(file_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release selection iterator");
if (file_iter)
file_iter = H5FL_FREE(H5S_sel_iter_t, file_iter);
if (mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release selection iterator");
if (mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
@ -414,13 +414,13 @@ done:
/* Release selection iterators */
if (src_sel_iter) {
if (src_sel_iter_init && H5S_SELECT_ITER_RELEASE(src_sel_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator");
src_sel_iter = H5FL_FREE(H5S_sel_iter_t, src_sel_iter);
}
if (dst_sel_iter) {
if (dst_sel_iter_init && H5S_SELECT_ITER_RELEASE(dst_sel_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator");
dst_sel_iter = H5FL_FREE(H5S_sel_iter_t, dst_sel_iter);
}

44
src/H5Dvirtual.c
View File

@ -277,7 +277,7 @@ done:
/* Free temporary space */
if (tmp_space)
if (H5S_close(tmp_space) < 0)
HDONE_ERROR(H5E_PLIST, H5E_CLOSEERROR, FAIL, "can't close dataspace")
HDONE_ERROR(H5E_PLIST, H5E_CLOSEERROR, FAIL, "can't close dataspace");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D_virtual_check_mapping_post() */
@ -670,7 +670,7 @@ done:
/* Release allocated resources on failure */
if (ret_value < 0)
if (H5D__virtual_reset_layout(layout) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to reset virtual layout")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to reset virtual layout");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__virtual_copy_layout() */
@ -707,7 +707,7 @@ H5D__virtual_reset_layout(H5O_layout_t *layout)
H5O_storage_virtual_ent_t *ent = &virt->list[i];
/* Free source_dset */
if (H5D__virtual_reset_source_dset(ent, &ent->source_dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to reset source dataset")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to reset source dataset");
/* Free original source names */
(void)H5MM_xfree(ent->source_file_name);
@ -716,13 +716,13 @@ H5D__virtual_reset_layout(H5O_layout_t *layout)
/* Free sub_dset */
for (j = 0; j < ent->sub_dset_nalloc; j++)
if (H5D__virtual_reset_source_dset(ent, &ent->sub_dset[j]) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to reset source dataset")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to reset source dataset");
ent->sub_dset = H5MM_xfree(ent->sub_dset);
/* Free source_select */
if (ent->source_select)
if (H5S_close(ent->source_select) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release source selection")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release source selection");
/* Free parsed_source_file_name */
H5D_virtual_free_parsed_name(ent->parsed_source_file_name);
@ -740,12 +740,12 @@ H5D__virtual_reset_layout(H5O_layout_t *layout)
/* Close access property lists */
if (virt->source_fapl >= 0) {
if (H5I_dec_ref(virt->source_fapl) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't close source fapl")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't close source fapl");
virt->source_fapl = -1;
}
if (virt->source_dapl >= 0) {
if (H5I_dec_ref(virt->source_dapl) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't close source dapl")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't close source dapl");
virt->source_dapl = -1;
}
@ -927,7 +927,7 @@ done:
/* Release resources */
if (src_file_open)
if (H5F_efc_close(vdset->oloc.file, src_file) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEFILE, FAIL, "can't close source file")
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEFILE, FAIL, "can't close source file");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__virtual_open_source_dset() */
@ -955,7 +955,7 @@ H5D__virtual_reset_source_dset(H5O_storage_virtual_ent_t *virtual_ent,
/* Free dataset */
if (source_dset->dset) {
if (H5D_close(source_dset->dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to close source dataset")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to close source dataset");
source_dset->dset = NULL;
} /* end if */
@ -983,14 +983,14 @@ H5D__virtual_reset_source_dset(H5O_storage_virtual_ent_t *virtual_ent,
if (source_dset->clipped_virtual_select) {
if (source_dset->clipped_virtual_select != source_dset->virtual_select)
if (H5S_close(source_dset->clipped_virtual_select) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release clipped virtual selection")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release clipped virtual selection");
source_dset->clipped_virtual_select = NULL;
} /* end if */
/* Free virtual selection */
if (source_dset->virtual_select) {
if (H5S_close(source_dset->virtual_select) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release virtual selection")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release virtual selection");
source_dset->virtual_select = NULL;
} /* end if */
@ -998,7 +998,7 @@ H5D__virtual_reset_source_dset(H5O_storage_virtual_ent_t *virtual_ent,
if (source_dset->clipped_source_select) {
if (source_dset->clipped_source_select != virtual_ent->source_select)
if (H5S_close(source_dset->clipped_source_select) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release clipped source selection")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release clipped source selection");
source_dset->clipped_source_select = NULL;
} /* end if */
@ -1610,7 +1610,7 @@ H5D__virtual_set_extent_unlim(const H5D_t *dset)
* numbers of datasets open */
if (H5D_close(storage->list[i].sub_dset[j].dset) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL,
"unable to close source dataset")
"unable to close source dataset");
storage->list[i].sub_dset[j].dset = NULL;
} /* end if */
} /* end else */
@ -2613,7 +2613,7 @@ H5D__virtual_post_io(H5O_storage_virtual_t *storage)
/* Close projected memory space */
if (storage->list[i].sub_dset[j].projected_mem_space) {
if (H5S_close(storage->list[i].sub_dset[j].projected_mem_space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close temporary space")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close temporary space");
storage->list[i].sub_dset[j].projected_mem_space = NULL;
} /* end if */
} /* end if */
@ -2621,7 +2621,7 @@ H5D__virtual_post_io(H5O_storage_virtual_t *storage)
/* Close projected memory space */
if (storage->list[i].source_dset.projected_mem_space) {
if (H5S_close(storage->list[i].source_dset.projected_mem_space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close temporary space")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close temporary space");
storage->list[i].source_dset.projected_mem_space = NULL;
} /* end if */
@ -2689,7 +2689,7 @@ done:
if (projected_src_space) {
assert(ret_value < 0);
if (H5S_close(projected_src_space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close projected source space")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close projected source space");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -2815,12 +2815,12 @@ H5D__virtual_read(H5D_io_info_t H5_ATTR_NDEBUG_UNUSED *io_info, H5D_dset_io_info
done:
/* Cleanup I/O operation */
if (H5D__virtual_post_io(storage) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't cleanup I/O operation")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't cleanup I/O operation");
/* Close fill space */
if (fill_space)
if (H5S_close(fill_space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close fill space")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close fill space");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__virtual_read() */
@ -2886,7 +2886,7 @@ done:
if (projected_src_space) {
assert(ret_value < 0);
if (H5S_close(projected_src_space) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close projected source space")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't close projected source space");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -2962,7 +2962,7 @@ H5D__virtual_write(H5D_io_info_t H5_ATTR_NDEBUG_UNUSED *io_info, H5D_dset_io_inf
done:
/* Cleanup I/O operation */
if (H5D__virtual_post_io(storage) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't cleanup I/O operation")
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "can't cleanup I/O operation");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__virtual_write() */
@ -3076,7 +3076,7 @@ done:
if (ret_value < 0)
/* Release hold on files and delete list on error */
if (*head && H5D__virtual_release_source_dset_files(*head) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't release source datasets' files held open")
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "can't release source datasets' files held open");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__virtual_hold_source_dset_files() */
@ -3119,7 +3119,7 @@ H5D__virtual_refresh_source_dset(H5D_t **dset)
done:
if (vol_obj && H5VL_free_object(vol_obj) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "unable to free VOL object")
HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "unable to free VOL object");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__virtual_refresh_source_dset() */

4
src/H5E.c
View File

@ -449,7 +449,7 @@ H5E__register_class(const char *cls_name, const char *lib_name, const char *vers
done:
if (!ret_value)
if (cls && H5E__free_class(cls) < 0)
HDONE_ERROR(H5E_ERROR, H5E_CANTRELEASE, NULL, "unable to free error class")
HDONE_ERROR(H5E_ERROR, H5E_CANTRELEASE, NULL, "unable to free error class");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5E__register_class() */
@ -752,7 +752,7 @@ H5E__create_msg(H5E_cls_t *cls, H5E_type_t msg_type, const char *msg_str)
done:
if (!ret_value)
if (msg && H5E__close_msg(msg, NULL) < 0)
HDONE_ERROR(H5E_ERROR, H5E_CANTCLOSEOBJ, NULL, "unable to close error message")
HDONE_ERROR(H5E_ERROR, H5E_CANTCLOSEOBJ, NULL, "unable to close error message");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5E__create_msg() */

25
src/H5EA.c
View File

@ -151,10 +151,10 @@ H5EA__new(H5F_t *f, haddr_t ea_addr, hbool_t from_open, void *ctx_udata)
done:
if (hdr && H5EA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, NULL, "unable to release extensible array header")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, NULL, "unable to release extensible array header");
if (!ret_value)
if (ea && H5EA_close(ea) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CLOSEERROR, NULL, "unable to close extensible array")
HDONE_ERROR(H5E_EARRAY, H5E_CLOSEERROR, NULL, "unable to close extensible array");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__new() */
@ -200,7 +200,7 @@ H5EA_create(H5F_t *f, const H5EA_create_t *cparam, void *ctx_udata)
done:
if (!ret_value)
if (ea && H5EA_close(ea) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CLOSEERROR, NULL, "unable to close extensible array")
HDONE_ERROR(H5E_EARRAY, H5E_CLOSEERROR, NULL, "unable to close extensible array");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA_create() */
@ -238,7 +238,7 @@ H5EA_open(H5F_t *f, haddr_t ea_addr, void *ctx_udata)
done:
if (!ret_value)
if (ea && H5EA_close(ea) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CLOSEERROR, NULL, "unable to close extensible array")
HDONE_ERROR(H5E_EARRAY, H5E_CLOSEERROR, NULL, "unable to close extensible array");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA_open() */
@ -616,18 +616,19 @@ done:
if (hdr_dirty)
if (H5EA__hdr_modified(hdr) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTMARKDIRTY, FAIL,
"unable to mark extensible array header as modified")
"unable to mark extensible array header as modified");
/* Release resources */
if (iblock && *thing != iblock && H5EA__iblock_unprotect(iblock, iblock_cache_flags) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array index block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array index block");
/* (Note: super blocks don't contain elements, so don't have a '*thing != sblock' check) */
if (sblock && H5EA__sblock_unprotect(sblock, sblock_cache_flags) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array super block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array super block");
if (dblock && *thing != dblock && H5EA__dblock_unprotect(dblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array data block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array data block");
if (dblk_page && *thing != dblk_page && H5EA__dblk_page_unprotect(dblk_page, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array data block page")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL,
"unable to release extensible array data block page");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__lookup_elmt() */
@ -690,7 +691,7 @@ H5EA_set(const H5EA_t *ea, hsize_t idx, const void *elmt)
done:
/* Release resources */
if (thing && (thing_unprot_func)(thing, thing_cache_flags) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array metadata")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array metadata");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA_set() */
@ -752,7 +753,7 @@ H5EA_get(const H5EA_t *ea, hsize_t idx, void *elmt)
done:
/* Release thing */
if (thing && (thing_unprot_func)(thing, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array metadata")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array metadata");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA_get() */
@ -943,7 +944,7 @@ H5EA_delete(H5F_t *f, haddr_t ea_addr, void *ctx_udata)
done:
/* Unprotect the header if an error occurred */
if (hdr && H5EA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA_delete() */

10
src/H5EAcache.c
View File

@ -385,7 +385,7 @@ done:
/* Release resources */
if (!ret_value)
if (hdr && H5EA__hdr_dest(hdr) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array header")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__cache_hdr_deserialize() */
@ -756,7 +756,7 @@ done:
/* Release resources */
if (!ret_value)
if (iblock && H5EA__iblock_dest(iblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array index block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array index block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__cache_iblock_deserialize() */
@ -1153,7 +1153,7 @@ done:
/* Release resources */
if (!ret_value)
if (sblock && H5EA__sblock_dest(sblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array super block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array super block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__cache_sblock_deserialize() */
@ -1559,7 +1559,7 @@ done:
/* Release resources */
if (!ret_value)
if (dblock && H5EA__dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array data block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array data block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__cache_dblock_deserialize() */
@ -1950,7 +1950,7 @@ done:
/* Release resources */
if (!ret_value)
if (dblk_page && H5EA__dblk_page_dest(dblk_page) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array data block page")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array data block page");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__cache_dblk_page_deserialize() */

26
src/H5EAdbg.c
View File

@ -136,9 +136,10 @@ H5EA__hdr_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, co
done:
if (dbg_ctx && cls->dst_dbg_ctx(dbg_ctx) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTRELEASE, FAIL, "unable to release extensible array debugging context")
HDONE_ERROR(H5E_EARRAY, H5E_CANTRELEASE, FAIL,
"unable to release extensible array debugging context");
if (hdr && H5EA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__hdr_debug() */
@ -251,11 +252,12 @@ H5EA__iblock_debug(H5F_t *f, haddr_t H5_ATTR_UNUSED addr, FILE *stream, int inde
done:
if (dbg_ctx && cls->dst_dbg_ctx(dbg_ctx) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTRELEASE, FAIL, "unable to release extensible array debugging context")
HDONE_ERROR(H5E_EARRAY, H5E_CANTRELEASE, FAIL,
"unable to release extensible array debugging context");
if (iblock && H5EA__iblock_unprotect(iblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array index block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array index block");
if (hdr && H5EA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__iblock_debug() */
@ -337,11 +339,12 @@ H5EA__sblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
done:
if (dbg_ctx && cls->dst_dbg_ctx(dbg_ctx) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTRELEASE, FAIL, "unable to release extensible array debugging context")
HDONE_ERROR(H5E_EARRAY, H5E_CANTRELEASE, FAIL,
"unable to release extensible array debugging context");
if (sblock && H5EA__sblock_unprotect(sblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array super block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array super block");
if (hdr && H5EA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__sblock_debug() */
@ -413,11 +416,12 @@ H5EA__dblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
done:
if (dbg_ctx && cls->dst_dbg_ctx(dbg_ctx) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTRELEASE, FAIL, "unable to release extensible array debugging context")
HDONE_ERROR(H5E_EARRAY, H5E_CANTRELEASE, FAIL,
"unable to release extensible array debugging context");
if (dblock && H5EA__dblock_unprotect(dblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array data block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array data block");
if (hdr && H5EA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__dblock_debug() */

8
src/H5EAdblkpage.c
View File

@ -113,7 +113,7 @@ H5EA__dblk_page_alloc(H5EA_hdr_t *hdr, H5EA_sblock_t *parent)
done:
if (!ret_value)
if (dblk_page && H5EA__dblk_page_dest(dblk_page) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array data block page")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array data block page");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__dblk_page_alloc() */
@ -173,12 +173,12 @@ done:
if (inserted)
if (H5AC_remove_entry(dblk_page) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTREMOVE, FAIL,
"unable to remove extensible array data block page from cache")
"unable to remove extensible array data block page from cache");
/* Destroy data block page */
if (H5EA__dblk_page_dest(dblk_page) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, FAIL,
"unable to destroy extensible array data block page")
"unable to destroy extensible array data block page");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -242,7 +242,7 @@ done:
H5AC_unprotect(hdr->f, H5AC_EARRAY_DBLK_PAGE, dblk_page->addr, dblk_page, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, NULL,
"unable to unprotect extensible array data block page, address = %llu",
(unsigned long long)dblk_page->addr)
(unsigned long long)dblk_page->addr);
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__dblk_page_protect() */

12
src/H5EAdblock.c
View File

@ -125,7 +125,7 @@ H5EA__dblock_alloc(H5EA_hdr_t *hdr, void *parent, size_t nelmts)
done:
if (!ret_value)
if (dblock && H5EA__dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array data block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array data block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__dblock_alloc() */
@ -211,18 +211,18 @@ done:
if (inserted)
if (H5AC_remove_entry(dblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTREMOVE, HADDR_UNDEF,
"unable to remove extensible array data block from cache")
"unable to remove extensible array data block from cache");
/* Release data block's disk space */
if (H5_addr_defined(dblock->addr) &&
H5MF_xfree(hdr->f, H5FD_MEM_EARRAY_DBLOCK, dblock->addr, (hsize_t)dblock->size) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF,
"unable to release extensible array data block")
"unable to release extensible array data block");
/* Destroy data block */
if (H5EA__dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF,
"unable to destroy extensible array data block")
"unable to destroy extensible array data block");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -319,7 +319,7 @@ done:
H5AC_unprotect(hdr->f, H5AC_EARRAY_DBLOCK, dblock->addr, dblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, NULL,
"unable to unprotect extensible array data block, address = %llu",
(unsigned long long)dblock->addr)
(unsigned long long)dblock->addr);
}
FUNC_LEAVE_NOAPI(ret_value)
@ -412,7 +412,7 @@ done:
/* Finished deleting data block in metadata cache */
if (dblock && H5EA__dblock_unprotect(dblock, H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG |
H5AC__FREE_FILE_SPACE_FLAG) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array data block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array data block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__dblock_delete() */

8
src/H5EAhdr.c
View File

@ -127,7 +127,7 @@ H5EA__hdr_alloc(H5F_t *f)
done:
if (!ret_value)
if (hdr && H5EA__hdr_dest(hdr) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array header")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__hdr_alloc() */
@ -431,17 +431,17 @@ done:
if (inserted)
if (H5AC_remove_entry(hdr) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTREMOVE, HADDR_UNDEF,
"unable to remove extensible array header from cache")
"unable to remove extensible array header from cache");
/* Release header's disk space */
if (H5_addr_defined(hdr->addr) &&
H5MF_xfree(f, H5FD_MEM_EARRAY_HDR, hdr->addr, (hsize_t)hdr->size) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to free extensible array header")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to free extensible array header");
/* Destroy header */
if (H5EA__hdr_dest(hdr) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF,
"unable to destroy extensible array header")
"unable to destroy extensible array header");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)

12
src/H5EAiblock.c
View File

@ -140,7 +140,7 @@ H5EA__iblock_alloc(H5EA_hdr_t *hdr)
done:
if (!ret_value)
if (iblock && H5EA__iblock_dest(iblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array index block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array index block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__iblock_alloc() */
@ -241,18 +241,18 @@ done:
if (inserted)
if (H5AC_remove_entry(iblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTREMOVE, HADDR_UNDEF,
"unable to remove extensible array index block from cache")
"unable to remove extensible array index block from cache");
/* Release index block's disk space */
if (H5_addr_defined(iblock->addr) &&
H5MF_xfree(hdr->f, H5FD_MEM_EARRAY_IBLOCK, iblock->addr, (hsize_t)iblock->size) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF,
"unable to release file space for extensible array index block")
"unable to release file space for extensible array index block");
/* Destroy index block */
if (H5EA__iblock_dest(iblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF,
"unable to destroy extensible array index block")
"unable to destroy extensible array index block");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -308,7 +308,7 @@ done:
H5AC_unprotect(hdr->f, H5AC_EARRAY_IBLOCK, iblock->addr, iblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, NULL,
"unable to unprotect extensible array index block, address = %llu",
(unsigned long long)iblock->addr)
(unsigned long long)iblock->addr);
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -422,7 +422,7 @@ done:
/* Finished deleting index block in metadata cache */
if (iblock && H5EA__iblock_unprotect(iblock, H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG |
H5AC__FREE_FILE_SPACE_FLAG) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array index block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array index block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__iblock_delete() */

12
src/H5EAsblock.c
View File

@ -152,7 +152,7 @@ H5EA__sblock_alloc(H5EA_hdr_t *hdr, H5EA_iblock_t *parent, unsigned sblk_idx)
done:
if (!ret_value)
if (sblock && H5EA__sblock_dest(sblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array super block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, NULL, "unable to destroy extensible array super block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__sblock_alloc() */
@ -232,18 +232,18 @@ done:
if (inserted)
if (H5AC_remove_entry(sblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTREMOVE, HADDR_UNDEF,
"unable to remove extensible array super block from cache")
"unable to remove extensible array super block from cache");
/* Release super block's disk space */
if (H5_addr_defined(sblock->addr) &&
H5MF_xfree(hdr->f, H5FD_MEM_EARRAY_SBLOCK, sblock->addr, (hsize_t)sblock->size) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF,
"unable to release extensible array super block")
"unable to release extensible array super block");
/* Destroy super block */
if (H5EA__sblock_dest(sblock) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF,
"unable to destroy extensible array super block")
"unable to destroy extensible array super block");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -308,7 +308,7 @@ done:
H5AC_unprotect(hdr->f, H5AC_EARRAY_SBLOCK, sblock->addr, sblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, NULL,
"unable to unprotect extensible array super block, address = %llu",
(unsigned long long)sblock->addr)
(unsigned long long)sblock->addr);
}
FUNC_LEAVE_NOAPI(ret_value)
@ -386,7 +386,7 @@ done:
/* Finished deleting super block in metadata cache */
if (sblock && H5EA__sblock_unprotect(sblock, H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG |
H5AC__FREE_FILE_SPACE_FLAG) < 0)
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array super block")
HDONE_ERROR(H5E_EARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release extensible array super block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5EA__sblock_delete() */

2
src/H5ES.c
View File

@ -139,7 +139,7 @@ done:
if (ret_value < 0)
/* Release newly created connector */
if (connector && H5VL_conn_dec_rc(connector) < 0)
HDONE_ERROR(H5E_EVENTSET, H5E_CANTDEC, FAIL, "unable to decrement ref count on VOL connector")
HDONE_ERROR(H5E_EVENTSET, H5E_CANTDEC, FAIL, "unable to decrement ref count on VOL connector");
FUNC_LEAVE_API(ret_value)
} /* end H5ESinsert_request() */

2
src/H5ESevent.c
View File

@ -94,7 +94,7 @@ H5ES__event_new(H5VL_t *connector, void *token)
/* Create vol object for token */
if (NULL == (request = H5VL_create_object(token, connector))) {
if (H5VL_request_free(token) < 0)
HDONE_ERROR(H5E_EVENTSET, H5E_CANTFREE, NULL, "can't free request")
HDONE_ERROR(H5E_EVENTSET, H5E_CANTFREE, NULL, "can't free request");
HGOTO_ERROR(H5E_EVENTSET, H5E_CANTINIT, NULL, "can't create vol object for request token")
} /* end if */

4
src/H5ESint.c
View File

@ -225,7 +225,7 @@ H5ES__create(void)
done:
if (!ret_value)
if (es && H5ES__close(es) < 0)
HDONE_ERROR(H5E_EVENTSET, H5E_CANTRELEASE, NULL, "unable to free event set")
HDONE_ERROR(H5E_EVENTSET, H5E_CANTRELEASE, NULL, "unable to free event set");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5ES__create() */
@ -297,7 +297,7 @@ done:
if (ev_inserted)
H5ES__list_remove(&es->active, ev);
if (H5ES__event_free(ev) < 0)
HDONE_ERROR(H5E_EVENTSET, H5E_CANTRELEASE, FAIL, "unable to release event")
HDONE_ERROR(H5E_EVENTSET, H5E_CANTRELEASE, FAIL, "unable to release event");
}
FUNC_LEAVE_NOAPI(ret_value)

24
src/H5Eprivate.h
View File

@ -30,16 +30,20 @@ typedef struct H5E_t H5E_t;
* error number, the minor error number, and a description of the error.
*/
#define HERROR(maj_id, min_id, ...) \
H5E_printf_stack(NULL, __FILE__, __func__, __LINE__, H5E_ERR_CLS_g, maj_id, min_id, __VA_ARGS__)
do { \
H5E_printf_stack(NULL, __FILE__, __func__, __LINE__, H5E_ERR_CLS_g, maj_id, min_id, __VA_ARGS__); \
} while (0)
/*
* HCOMMON_ERROR macro, used by HDONE_ERROR and HGOTO_ERROR
* (Shouldn't need to be used outside this header file)
*/
#define HCOMMON_ERROR(maj, min, ...) \
HERROR(maj, min, __VA_ARGS__); \
err_occurred = TRUE; \
err_occurred = err_occurred; /* Shut GCC warnings up! */
do { \
HERROR(maj, min, __VA_ARGS__); \
err_occurred = TRUE; \
err_occurred = err_occurred; /* Shut GCC warnings up! */ \
} while (0)
/*
* HDONE_ERROR macro, used to facilitate error reporting between a
@ -51,10 +55,10 @@ typedef struct H5E_t H5E_t;
* without jumping to any labels)
*/
#define HDONE_ERROR(maj, min, ret_val, ...) \
{ \
do { \
HCOMMON_ERROR(maj, min, __VA_ARGS__); \
ret_value = ret_val; \
}
} while (0)
/*
* HGOTO_ERROR macro, used to facilitate error reporting between a
@ -74,11 +78,11 @@ typedef struct H5E_t H5E_t;
* H5_END_TAG statements. Resets the metadata tag before leaving the function.
*/
#define HGOTO_ERROR_TAG(maj, min, ret_val, ...) \
{ \
do { \
H5AC_tag(prv_tag, NULL); \
HCOMMON_ERROR(maj, min, __VA_ARGS__); \
HGOTO_DONE(ret_val); \
}
} while (0)
/*
* HGOTO_DONE macro, used to facilitate normal return between a FUNC_ENTER()
@ -97,10 +101,10 @@ typedef struct H5E_t H5E_t;
* H5_END_TAG statements. Resets the metadata tag before leaving the function.
*/
#define HGOTO_DONE_TAG(ret_val) \
{ \
do { \
H5AC_tag(prv_tag, NULL); \
HGOTO_DONE(ret_val); \
}
} while (0)
/*
* Macros handling system error messages as described in C standard.

16
src/H5F.c
View File

@ -713,7 +713,7 @@ H5Fcreate_async(const char *app_file, const char *app_func, unsigned app_line, c
H5ARG_TRACE8(__func__, "*s*sIu*sIuiii", app_file, app_func, app_line, filename, flags, fcpl_id, fapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref(ret_value) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on file ID")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on file ID");
HGOTO_ERROR(H5E_FILE, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -890,7 +890,7 @@ H5Fopen_async(const char *app_file, const char *app_func, unsigned app_line, con
H5ARG_TRACE7(__func__, "*s*sIu*sIuii", app_file, app_func, app_line, filename, flags, fapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref(ret_value) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on file ID")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on file ID");
HGOTO_ERROR(H5E_FILE, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -1119,7 +1119,7 @@ H5Fclose_async(const char *app_file, const char *app_func, unsigned app_line, hi
done:
if (connector && H5VL_conn_dec_rc(connector) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "can't decrement ref count on connector")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "can't decrement ref count on connector");
FUNC_LEAVE_API(ret_value)
} /* end H5Fclose_async() */
@ -1294,9 +1294,9 @@ done:
if (grp) {
assert(loc_vol_obj);
if (H5VL_group_close(loc_vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_FILE, H5E_CLOSEERROR, FAIL, "unable to release group")
HDONE_ERROR(H5E_FILE, H5E_CLOSEERROR, FAIL, "unable to release group");
if (H5VL_free_object(loc_vol_obj) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "unable to free VOL object")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "unable to free VOL object");
} /* end if */
FUNC_LEAVE_API(ret_value)
@ -1390,9 +1390,9 @@ done:
if (grp) {
assert(loc_vol_obj);
if (H5VL_group_close(loc_vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_FILE, H5E_CLOSEERROR, FAIL, "unable to release group")
HDONE_ERROR(H5E_FILE, H5E_CLOSEERROR, FAIL, "unable to release group");
if (H5VL_free_object(loc_vol_obj) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "unable to free VOL object")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "unable to free VOL object");
} /* end if */
FUNC_LEAVE_API(ret_value)
@ -1526,7 +1526,7 @@ H5Freopen_async(const char *app_file, const char *app_func, unsigned app_line, h
H5ARG_TRACE5(__func__, "*s*sIuii", app_file, app_func, app_line, file_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref(ret_value) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on file ID")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on file ID");
HGOTO_ERROR(H5E_FILE, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */

20
src/H5FA.c
View File

@ -139,10 +139,10 @@ H5FA__new(H5F_t *f, haddr_t fa_addr, hbool_t from_open, void *ctx_udata)
done:
if (hdr && H5FA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, NULL, "unable to release fixed array header")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, NULL, "unable to release fixed array header");
if (!ret_value)
if (fa && H5FA_close(fa) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CLOSEERROR, NULL, "unable to close fixed array")
HDONE_ERROR(H5E_FARRAY, H5E_CLOSEERROR, NULL, "unable to close fixed array");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__new() */
@ -188,7 +188,7 @@ H5FA_create(H5F_t *f, const H5FA_create_t *cparam, void *ctx_udata)
done:
if (!ret_value)
if (fa && H5FA_close(fa) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CLOSEERROR, NULL, "unable to close fixed array")
HDONE_ERROR(H5E_FARRAY, H5E_CLOSEERROR, NULL, "unable to close fixed array");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA_create() */
@ -226,7 +226,7 @@ H5FA_open(H5F_t *f, haddr_t fa_addr, void *ctx_udata)
done:
if (!ret_value)
if (fa && H5FA_close(fa) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CLOSEERROR, NULL, "unable to close fixed array")
HDONE_ERROR(H5E_FARRAY, H5E_CLOSEERROR, NULL, "unable to close fixed array");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA_open() */
@ -381,13 +381,13 @@ done:
/* Check for header modified */
if (hdr_dirty)
if (H5FA__hdr_modified(hdr) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTMARKDIRTY, FAIL, "unable to mark fixed array header as modified")
HDONE_ERROR(H5E_FARRAY, H5E_CANTMARKDIRTY, FAIL, "unable to mark fixed array header as modified");
/* Release resources */
if (dblock && H5FA__dblock_unprotect(dblock, dblock_cache_flags) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block");
if (dblk_page && H5FA__dblk_page_unprotect(dblk_page, dblk_page_cache_flags) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block page")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block page");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA_set() */
@ -486,9 +486,9 @@ H5FA_get(const H5FA_t *fa, hsize_t idx, void *elmt)
done:
if (dblock && H5FA__dblock_unprotect(dblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block");
if (dblk_page && H5FA__dblk_page_unprotect(dblk_page, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block page")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block page");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA_get() */
@ -634,7 +634,7 @@ H5FA_delete(H5F_t *f, haddr_t fa_addr, void *ctx_udata)
done:
/* Unprotect the header if an error occurred */
if (hdr && H5FA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array header")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA_delete() */

6
src/H5FAcache.c
View File

@ -317,7 +317,7 @@ done:
/* Release resources */
if (!ret_value)
if (hdr && H5FA__hdr_dest(hdr) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array header")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__cache_hdr_deserialize() */
@ -687,7 +687,7 @@ done:
/* Release resources */
if (!ret_value)
if (dblock && H5FA__dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__cache_dblock_deserialize() */
@ -1063,7 +1063,7 @@ done:
/* Release resources */
if (!ret_value)
if (dblk_page && H5FA__dblk_page_dest(dblk_page) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block page")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block page");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__cache_dblk_page_deserialize() */

10
src/H5FAdbg.c
View File

@ -127,9 +127,9 @@ H5FA__hdr_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, co
done:
if (dbg_ctx && cls->dst_dbg_ctx(dbg_ctx) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTRELEASE, FAIL, "unable to release fixed array debugging context")
HDONE_ERROR(H5E_FARRAY, H5E_CANTRELEASE, FAIL, "unable to release fixed array debugging context");
if (hdr && H5FA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array header")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__hdr_debug() */
@ -257,11 +257,11 @@ H5FA__dblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
done:
if (dbg_ctx && cls->dst_dbg_ctx(dbg_ctx) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTRELEASE, FAIL, "unable to release fixed array debugging context")
HDONE_ERROR(H5E_FARRAY, H5E_CANTRELEASE, FAIL, "unable to release fixed array debugging context");
if (dblock && H5FA__dblock_unprotect(dblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block");
if (hdr && H5FA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array header")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblock_debug() */

8
src/H5FAdblkpage.c
View File

@ -116,7 +116,7 @@ done:
if (!ret_value)
if (dblk_page && H5FA__dblk_page_dest(dblk_page) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block page")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block page");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblk_page_alloc() */
@ -183,11 +183,11 @@ done:
if (inserted)
if (H5AC_remove_entry(dblk_page) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTREMOVE, FAIL,
"unable to remove fixed array data block page from cache")
"unable to remove fixed array data block page from cache");
/* Destroy data block page */
if (H5FA__dblk_page_dest(dblk_page) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, FAIL, "unable to destroy fixed array data block page")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, FAIL, "unable to destroy fixed array data block page");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -256,7 +256,7 @@ done:
H5AC_unprotect(hdr->f, H5AC_FARRAY_DBLK_PAGE, dblk_page->addr, dblk_page, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, NULL,
"unable to unprotect fixed array data block page, address = %llu",
(unsigned long long)dblk_page->addr)
(unsigned long long)dblk_page->addr);
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)

12
src/H5FAdblock.c
View File

@ -152,7 +152,7 @@ H5FA__dblock_alloc(H5FA_hdr_t *hdr)
done:
if (!ret_value)
if (dblock && H5FA__dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblock_alloc() */
@ -228,16 +228,18 @@ done:
if (inserted)
if (H5AC_remove_entry(dblock) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTREMOVE, HADDR_UNDEF,
"unable to remove fixed array data block from cache")
"unable to remove fixed array data block from cache");
/* Release data block's disk space */
if (H5_addr_defined(dblock->addr) &&
H5MF_xfree(hdr->f, H5FD_MEM_FARRAY_DBLOCK, dblock->addr, (hsize_t)dblock->size) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to release fixed array data block")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF,
"unable to release fixed array data block");
/* Destroy data block */
if (H5FA__dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to destroy fixed array data block")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF,
"unable to destroy fixed array data block");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -383,7 +385,7 @@ done:
/* Finished deleting data block in metadata cache */
if (dblock && H5FA__dblock_unprotect(dblock, H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG |
H5AC__FREE_FILE_SPACE_FLAG) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array data block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__dblock_delete() */

10
src/H5FAhdr.c
View File

@ -108,7 +108,7 @@ H5FA__hdr_alloc(H5F_t *f)
done:
if (!ret_value)
if (hdr && H5FA__hdr_dest(hdr) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array header")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__hdr_alloc() */
@ -227,16 +227,16 @@ done:
if (inserted)
if (H5AC_remove_entry(hdr) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTREMOVE, HADDR_UNDEF,
"unable to remove fixed array header from cache")
"unable to remove fixed array header from cache");
/* Release header's disk space */
if (H5_addr_defined(hdr->addr) &&
H5MF_xfree(f, H5FD_MEM_FARRAY_HDR, hdr->addr, (hsize_t)hdr->size) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to free Fixed Array header")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to free Fixed Array header");
/* Destroy header */
if (H5FA__hdr_dest(hdr) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to destroy Fixed Array header")
HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to destroy Fixed Array header");
}
FUNC_LEAVE_NOAPI(ret_value)
@ -518,7 +518,7 @@ H5FA__hdr_delete(H5FA_hdr_t *hdr)
done:
/* Unprotect the header, deleting it if an error hasn't occurred */
if (H5AC_unprotect(hdr->f, H5AC_FARRAY_HDR, hdr->addr, hdr, cache_flags) < 0)
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array header")
HDONE_ERROR(H5E_FARRAY, H5E_CANTUNPROTECT, FAIL, "unable to release fixed array header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FA__hdr_delete() */

12
src/H5FDfamily.c
View File

@ -190,7 +190,7 @@ H5FD__family_get_default_config(H5FD_family_fapl_t *fa_out)
done:
if (ret_value < 0 && fa_out->memb_fapl_id >= 0) {
if (H5I_dec_ref(fa_out->memb_fapl_id) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't decrement ref. count on member FAPL ID")
HDONE_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't decrement ref. count on member FAPL ID");
}
FUNC_LEAVE_NOAPI(ret_value)
@ -820,7 +820,7 @@ done:
if (file->memb)
H5MM_xfree(file->memb);
if (H5I_dec_ref(file->memb_fapl_id) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTDEC, NULL, "can't close driver ID")
HDONE_ERROR(H5E_VFL, H5E_CANTDEC, NULL, "can't close driver ID");
if (file->name)
H5MM_xfree(file->name);
H5MM_xfree(file);
@ -865,12 +865,12 @@ H5FD__family_close(H5FD_t *_file)
} /* end for */
if (nerrors)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "unable to close member files")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "unable to close member files");
/* Clean up other stuff */
if (H5I_dec_ref(file->memb_fapl_id) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't close driver ID")
HDONE_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't close driver ID");
H5MM_xfree(file->memb);
H5MM_xfree(file->name);
H5MM_xfree(file);
@ -1365,7 +1365,7 @@ H5FD__family_lock(H5FD_t *_file, hbool_t rw)
for (v = 0; v < u; v++) {
if (H5FD_unlock(file->memb[v]) < 0)
/* Push error, but keep going */
HDONE_ERROR(H5E_IO, H5E_CANTUNLOCKFILE, FAIL, "unable to unlock member files")
HDONE_ERROR(H5E_IO, H5E_CANTUNLOCKFILE, FAIL, "unable to unlock member files");
} /* end for */
HGOTO_ERROR(H5E_IO, H5E_CANTLOCKFILE, FAIL, "unable to lock member files")
} /* end if */
@ -1512,7 +1512,7 @@ done:
/* Only close memb_fapl_id if we created one from the default configuration */
if (default_fa.memb_fapl_id >= 0 && H5I_dec_ref(default_fa.memb_fapl_id) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't decrement ref. count on member FAPL ID")
HDONE_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't decrement ref. count on member FAPL ID");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FD__family_delete() */

10
src/H5FDhdfs.c
View File

@ -449,12 +449,12 @@ done:
handle->magic++;
if (handle->file != NULL)
if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file)))
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close hdfs file handle")
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close hdfs file handle");
if (handle->fileinfo != NULL)
hdfsFreeFileInfo(handle->fileinfo, 1);
if (handle->filesystem != NULL)
if (FAIL == (hdfsDisconnect(handle->filesystem)))
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to disconnect from hdfs")
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to disconnect from hdfs");
H5MM_xfree(handle);
}
@ -491,12 +491,12 @@ H5FD__hdfs_handle_close(hdfs_t *handle)
handle->magic++;
if (handle->file != NULL)
if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file)))
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close hdfs file handle")
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close hdfs file handle");
if (handle->fileinfo != NULL)
hdfsFreeFileInfo(handle->fileinfo, 1);
if (handle->filesystem != NULL)
if (FAIL == (hdfsDisconnect(handle->filesystem)))
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to disconnect hdfs file system")
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to disconnect hdfs file system");
H5MM_xfree(handle);
@ -848,7 +848,7 @@ done:
if (ret_value == NULL) {
if (handle != NULL)
if (FAIL == H5FD__hdfs_handle_close(handle))
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close HDFS file handle")
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close HDFS file handle");
if (file != NULL)
file = H5FL_FREE(H5FD_hdfs_t, file);
} /* end if null return value (error) */

12
src/H5FDint.c
View File

@ -1175,7 +1175,7 @@ H5FD_read_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_s
if ((file_space_ids[num_spaces] = H5I_register(H5I_DATASPACE, file_spaces[num_spaces], TRUE)) <
0) {
if (NULL == H5I_remove(mem_space_ids[num_spaces]))
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id")
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id");
HGOTO_ERROR(H5E_VFL, H5E_CANTREGISTER, FAIL, "unable to register dataspace ID")
}
}
@ -1209,9 +1209,9 @@ done:
*/
for (i = 0; i < num_spaces; i++) {
if (NULL == H5I_remove(mem_space_ids[i]))
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id")
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id");
if (NULL == H5I_remove(file_space_ids[i]))
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id")
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id");
}
if (mem_space_ids != mem_space_ids_local)
mem_space_ids = H5MM_xfree(mem_space_ids);
@ -1808,7 +1808,7 @@ H5FD_write_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_
if ((file_space_ids[num_spaces] = H5I_register(H5I_DATASPACE, file_spaces[num_spaces], TRUE)) <
0) {
if (NULL == H5I_remove(mem_space_ids[num_spaces]))
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id")
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id");
HGOTO_ERROR(H5E_VFL, H5E_CANTREGISTER, FAIL, "unable to register dataspace ID")
}
}
@ -1842,9 +1842,9 @@ done:
*/
for (i = 0; i < num_spaces; i++) {
if (NULL == H5I_remove(mem_space_ids[i]))
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id")
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id");
if (NULL == H5I_remove(file_space_ids[i]))
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id")
HDONE_ERROR(H5E_VFL, H5E_CANTREMOVE, FAIL, "problem removing id");
}
if (mem_space_ids != mem_space_ids_local)
mem_space_ids = H5MM_xfree(mem_space_ids);

12
src/H5FDmpio.c
View File

@ -450,10 +450,10 @@ done:
if (ret_value != SUCCEED) {
if (comm)
if (H5_mpi_comm_free(comm) < 0)
HDONE_ERROR(H5E_PLIST, H5E_CANTFREE, FAIL, "unable to free MPI communicator")
HDONE_ERROR(H5E_PLIST, H5E_CANTFREE, FAIL, "unable to free MPI communicator");
if (info)
if (H5_mpi_info_free(info) < 0)
HDONE_ERROR(H5E_PLIST, H5E_CANTFREE, FAIL, "unable to free MPI info object")
HDONE_ERROR(H5E_PLIST, H5E_CANTFREE, FAIL, "unable to free MPI info object");
}
FUNC_LEAVE_API(ret_value)
@ -968,9 +968,9 @@ done:
if (file_opened)
MPI_File_close(&fh);
if (H5_mpi_comm_free(&comm) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTFREE, NULL, "unable to free MPI communicator")
HDONE_ERROR(H5E_VFL, H5E_CANTFREE, NULL, "unable to free MPI communicator");
if (H5_mpi_info_free(&info) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTFREE, NULL, "unable to free MPI info object")
HDONE_ERROR(H5E_VFL, H5E_CANTFREE, NULL, "unable to free MPI info object");
if (file)
H5MM_xfree(file);
} /* end if */
@ -2932,9 +2932,9 @@ H5FD__mpio_delete(const char *filename, hid_t fapl_id)
done:
/* Free duplicated MPI Communicator and Info objects */
if (H5_mpi_comm_free(&comm) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTFREE, FAIL, "unable to free MPI communicator")
HDONE_ERROR(H5E_VFL, H5E_CANTFREE, FAIL, "unable to free MPI communicator");
if (H5_mpi_info_free(&info) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTFREE, FAIL, "unable to free MPI info object")
HDONE_ERROR(H5E_VFL, H5E_CANTFREE, FAIL, "unable to free MPI info object");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FD__mpio_delete() */

20
src/H5FDonion.c
View File

@ -585,13 +585,13 @@ done:
/* Destroy things as best we can, even if there were earlier errors */
if (file->original_file)
if (H5FD_close(file->original_file) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close backing canon file")
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close backing canon file");
if (file->onion_file)
if (H5FD_close(file->onion_file) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close backing onion file")
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close backing onion file");
if (file->recovery_file) {
if (H5FD_close(file->recovery_file) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close backing recovery file")
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close backing recovery file");
/* TODO: Use the VFD's del callback instead of remove (this requires
* storing a copy of the fapl that was used to open it)
*/
@ -599,7 +599,7 @@ done:
}
if (file->rev_index)
if (H5FD__onion_revision_index_destroy(file->rev_index) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close revision index")
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close revision index");
H5MM_xfree(file->recovery_file_name);
H5MM_xfree(file->history.record_locs);
@ -1216,17 +1216,17 @@ done:
if (file->original_file)
if (H5FD_close(file->original_file) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy backing canon")
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy backing canon");
if (file->onion_file)
if (H5FD_close(file->onion_file) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy backing onion")
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy backing onion");
if (file->recovery_file)
if (H5FD_close(file->recovery_file) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy backing recov")
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy backing recov");
if (file->rev_index)
if (H5FD__onion_revision_index_destroy(file->rev_index) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy revision index")
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy revision index");
H5MM_xfree(file->history.record_locs);
@ -1309,13 +1309,13 @@ done:
if (FAIL == ret_value) {
if (file->recovery_file != NULL) {
if (H5FD_close(file->recovery_file) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "can't close recovery file")
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "can't close recovery file");
file->recovery_file = NULL;
}
if (file->rev_index != NULL) {
if (H5FD__onion_revision_index_destroy(file->rev_index) < 0)
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't destroy revision index")
HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't destroy revision index");
file->rev_index = NULL;
}
}

4
src/H5FDros3.c
View File

@ -663,7 +663,7 @@ H5FD__ros3_str_token_copy(const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED
HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't copy string property token")
done:
FUNC_LEAVE_NOAPI(ret_value);
FUNC_LEAVE_NOAPI(ret_value)
} /* H5FD__ros3_str_token_copy() */
/*-------------------------------------------------------------------------
@ -1006,7 +1006,7 @@ done:
if (ret_value == NULL) {
if (handle != NULL)
if (FAIL == H5FD_s3comms_s3r_close(handle))
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close s3 file handle")
HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close s3 file handle");
if (file != NULL)
file = H5FL_FREE(H5FD_ros3_t, file);
curl_global_cleanup(); /* early cleanup because open failed */

12
src/H5FDs3comms.c
View File

@ -1138,7 +1138,7 @@ done:
if (curlh != NULL)
curl_easy_cleanup(curlh);
if (FAIL == H5FD_s3comms_free_purl(purl))
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "unable to free parsed url structure")
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "unable to free parsed url structure");
if (handle != NULL) {
H5MM_xfree(handle->region);
H5MM_xfree(handle->secret_id);
@ -1542,21 +1542,21 @@ done:
if (request != NULL) {
while (headers != NULL)
if (FAIL == H5FD_s3comms_hrb_node_set(&headers, headers->name, NULL))
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "cannot release header node")
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "cannot release header node");
assert(NULL == headers);
if (FAIL == H5FD_s3comms_hrb_destroy(&request))
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "cannot release header request structure")
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "cannot release header request structure");
assert(NULL == request);
}
if (curlh != NULL) {
/* clear any Range */
if (CURLE_OK != curl_easy_setopt(curlh, CURLOPT_RANGE, NULL))
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "cannot unset CURLOPT_RANGE")
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "cannot unset CURLOPT_RANGE");
/* clear headers */
if (CURLE_OK != curl_easy_setopt(curlh, CURLOPT_HTTPHEADER, NULL))
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "cannot unset CURLOPT_HTTPHEADER")
HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "cannot unset CURLOPT_HTTPHEADER");
}
FUNC_LEAVE_NOAPI(ret_value)
@ -2116,7 +2116,7 @@ H5FD_s3comms_load_aws_profile(const char *profile_name, char *key_id_out, char *
done:
if (credfile != NULL)
if (fclose(credfile) == EOF)
HDONE_ERROR(H5E_ARGS, H5E_ARGS, FAIL, "problem error-closing aws configuration file")
HDONE_ERROR(H5E_ARGS, H5E_ARGS, FAIL, "problem error-closing aws configuration file");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FD_s3comms_load_aws_profile() */

4
src/H5FS.c
View File

@ -142,7 +142,7 @@ H5FS_create(H5F_t *f, haddr_t *fs_addr, const H5FS_create_t *fs_create, uint16_t
done:
if (!ret_value && fspace)
if (H5FS__hdr_dest(fspace) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTFREE, NULL, "unable to destroy free space header")
HDONE_ERROR(H5E_FSPACE, H5E_CANTFREE, NULL, "unable to destroy free space header");
#ifdef H5FS_DEBUG
fprintf(stderr, "%s: Leaving, ret_value = %p\n", __func__, (void *)ret_value);
@ -362,7 +362,7 @@ H5FS_delete(H5F_t *f, haddr_t fs_addr)
done:
if (fspace && H5AC_unprotect(f, H5AC_FSPACE_HDR, fs_addr, fspace,
H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTUNPROTECT, FAIL, "unable to release free space header")
HDONE_ERROR(H5E_FSPACE, H5E_CANTUNPROTECT, FAIL, "unable to release free space header");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5FS_delete() */

6
src/H5FScache.c
View File

@ -306,7 +306,7 @@ done:
/* Release resources */
if (!ret_value && fspace)
if (H5FS__hdr_dest(fspace) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTFREE, NULL, "unable to destroy free space header")
HDONE_ERROR(H5E_FSPACE, H5E_CANTFREE, NULL, "unable to destroy free space header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FS__cache_hdr_deserialize() */
@ -519,7 +519,7 @@ H5FS__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_AT
H5_BEGIN_TAG(tag)
if (H5AC_insert_entry((H5F_t *)f, H5AC_FSPACE_SINFO, fspace->sect_addr, fspace->sinfo,
H5AC__NO_FLAGS_SET) < 0)
HGOTO_ERROR_TAG(H5E_FSPACE, H5E_CANTINIT, FAIL, "can't add free space sections to cache")
HGOTO_ERROR_TAG(H5E_FSPACE, H5E_CANTINIT, FAIL, "can't add free space sections to cache");
H5_END_TAG
assert(fspace->sinfo->cache_info.size == fspace->alloc_sect_size);
@ -1056,7 +1056,7 @@ H5FS__cache_sinfo_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED l
done:
if (!ret_value && sinfo)
if (H5FS__sinfo_dest(sinfo) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTFREE, NULL, "unable to destroy free space info")
HDONE_ERROR(H5E_FSPACE, H5E_CANTFREE, NULL, "unable to destroy free space info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FS__cache_sinfo_deserialize() */

6
src/H5FSdbg.c
View File

@ -140,7 +140,7 @@ H5FS_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth)
done:
if (fspace && H5AC_unprotect(f, H5AC_FSPACE_HDR, addr, fspace, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_PROTECT, FAIL, "unable to release free space header")
HDONE_ERROR(H5E_FSPACE, H5E_PROTECT, FAIL, "unable to release free space header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FS_debug() */
@ -232,7 +232,7 @@ H5FS_sects_debug(H5F_t *f, haddr_t H5_ATTR_UNUSED addr, FILE *stream, int indent
* and reloaded later, with the correct client information -QAK)
*/
if (H5AC_unprotect(f, H5AC_FSPACE_HDR, fs_addr, fspace, H5AC__DELETED_FLAG) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_PROTECT, FAIL, "unable to release free space header")
HDONE_ERROR(H5E_FSPACE, H5E_PROTECT, FAIL, "unable to release free space header");
fspace = NULL;
/* Print opening message */
@ -260,7 +260,7 @@ H5FS_sects_debug(H5F_t *f, haddr_t H5_ATTR_UNUSED addr, FILE *stream, int indent
done:
if (fspace && H5AC_unprotect(f, H5AC_FSPACE_HDR, fs_addr, fspace, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_PROTECT, FAIL, "unable to release free space header")
HDONE_ERROR(H5E_FSPACE, H5E_PROTECT, FAIL, "unable to release free space header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5FS_sects_debug() */

18
src/H5FSsection.c
View File

@ -896,7 +896,7 @@ H5FS_sect_remove(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect)
done:
/* Release the section info */
if (sinfo_valid && H5FS__sinfo_unlock(f, fspace, TRUE) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info")
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5FS_sect_remove() */
@ -990,7 +990,7 @@ done:
if (fspace_node && fspace_node_alloc) {
if (fspace_node->sect_list && H5SL_close(fspace_node->sect_list) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTCLOSEOBJ, FAIL,
"can't destroy size free space node's skip list")
"can't destroy size free space node's skip list");
fspace_node = H5FL_FREE(H5FS_node_t, fspace_node);
} /* end if */
@ -1348,7 +1348,7 @@ H5FS_sect_add(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect, unsigned flag
done:
/* Release the section info */
if (sinfo_valid && H5FS__sinfo_unlock(f, fspace, sinfo_modified) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info")
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info");
#ifdef H5FS_DEBUG_ASSERT
if (!(flags & (H5FS_ADD_DESERIALIZING | H5FS_ADD_SKIP_VALID)))
@ -1490,7 +1490,7 @@ H5FS_sect_try_extend(H5F_t *f, H5FS_t *fspace, haddr_t addr, hsize_t size, hsize
done:
/* Release the section info */
if (sinfo_valid && H5FS__sinfo_unlock(f, fspace, sinfo_modified) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info")
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5FS_sect_try_extend() */
@ -1552,7 +1552,7 @@ H5FS_sect_try_merge(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect, unsigne
done:
/* Release the section info */
if (sinfo_valid && H5FS__sinfo_unlock(f, fspace, sinfo_modified) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info")
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5FS_sect_try_merge() */
@ -1753,7 +1753,7 @@ H5FS_sect_find(H5F_t *f, H5FS_t *fspace, hsize_t request, H5FS_section_info_t **
done:
/* Release the section info */
if (sinfo_valid && H5FS__sinfo_unlock(f, fspace, sinfo_modified) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info")
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info");
#ifdef H5FS_DEBUG_ASSERT
H5FS__assert(fspace);
@ -1876,7 +1876,7 @@ H5FS_sect_iterate(H5F_t *f, H5FS_t *fspace, H5FS_operator_t op, void *op_data)
done:
/* Release the section info */
if (sinfo_valid && H5FS__sinfo_unlock(f, fspace, FALSE) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info")
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5FS_sect_iterate() */
@ -2052,7 +2052,7 @@ H5FS_sect_change_class(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect, uint
done:
/* Release the section info */
if (sinfo_valid && H5FS__sinfo_unlock(f, fspace, TRUE) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info")
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5FS_sect_change_class() */
@ -2261,7 +2261,7 @@ H5FS_sect_try_shrink_eoa(H5F_t *f, H5FS_t *fspace, void *op_data)
done:
/* Release the section info */
if (sinfo_valid && H5FS__sinfo_unlock(f, fspace, section_removed) < 0)
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info")
HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5FS_sect_try_shrink_eoa() */

2
src/H5Fefc.c
View File

@ -311,7 +311,7 @@ done:
if (open_file) {
ent->file->nopen_objs--;
if (H5F_try_close(ent->file, NULL) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "can't close external file")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "can't close external file");
} /* end if */
ent->name = (char *)H5MM_xfree(ent->name);
ent = H5FL_FREE(H5F_efc_ent_t, ent);

108
src/H5Fint.c
View File

@ -447,7 +447,7 @@ H5F_get_access_plist(H5F_t *f, hbool_t app_ref)
done:
/* Release the copy of the driver info, if it was set up */
if (driver_prop_copied && H5FD_free_driver_info(driver_prop.driver_id, driver_prop.driver_info) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, H5I_INVALID_HID, "can't close copy of driver info")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, H5I_INVALID_HID, "can't close copy of driver info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F_get_access_plist() */
@ -1008,7 +1008,7 @@ H5F_prefix_open_file(H5F_t *primary_file, H5F_prefix_open_t prefix_type, const c
done:
if ((NULL == ret_value) && src_file)
if (H5F_efc_close(primary_file, src_file) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "can't close source file")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "can't close source file");
if (full_name)
full_name = (char *)H5MM_xfree(full_name);
if (temp_file_name)
@ -1063,7 +1063,7 @@ done:
/* Close the file */
if (file)
if (H5FD_close(file) < 0 && TRUE == ret_value)
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "unable to close file")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "unable to close file");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F__is_hdf5() */
@ -1328,10 +1328,10 @@ done:
/* Attempt to clean up some of the shared file structures */
if (f->shared->efc)
if (H5F__efc_destroy(f->shared->efc) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, NULL, "can't destroy external file cache")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, NULL, "can't destroy external file cache");
if (f->shared->fcpl_id > 0)
if (H5I_dec_ref(f->shared->fcpl_id) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, NULL, "can't close property list")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, NULL, "can't close property list");
f->shared = H5FL_FREE(H5F_shared_t, f->shared);
}
@ -1377,7 +1377,7 @@ H5F__dest(H5F_t *f, hbool_t flush)
if ((H5F_ACC_RDWR & H5F_INTENT(f)) && flush)
if (H5F__flush_phase1(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush cached data (phase 1)")
HDONE_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush cached data (phase 1)");
/* Notify the metadata cache that the file is about to be closed.
* This allows the cache to set up for creating a metadata cache
@ -1385,7 +1385,7 @@ H5F__dest(H5F_t *f, hbool_t flush)
*/
if (H5AC_prep_for_file_close(f) < 0)
/* Push error, but keep going */
HDONE_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "metadata cache prep for close failed")
HDONE_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "metadata cache prep for close failed");
/* Flush at this point since the file will be closed (phase 2).
* Only try to flush the file if it was opened with write access, and if
@ -1394,7 +1394,7 @@ H5F__dest(H5F_t *f, hbool_t flush)
if ((H5F_ACC_RDWR & H5F_INTENT(f)) && flush)
if (H5F__flush_phase2(f, TRUE) < 0)
/* Push error, but keep going */
HDONE_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush cached data (phase 2)")
HDONE_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush cached data (phase 2)");
/* With the shutdown modifications, the contents of the metadata cache
* should be clean at this point, with the possible exception of the
@ -1408,7 +1408,7 @@ H5F__dest(H5F_t *f, hbool_t flush)
if (f->shared->efc) {
if (H5F__efc_destroy(f->shared->efc) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't destroy external file cache")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't destroy external file cache");
f->shared->efc = NULL;
} /* end if */
@ -1441,7 +1441,7 @@ H5F__dest(H5F_t *f, hbool_t flush)
if (H5F_ACC_RDWR & H5F_INTENT(f)) {
if (H5MF_close(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release file free space info")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release file free space info");
/* at this point, only the superblock and superblock
* extension should be dirty.
@ -1459,7 +1459,7 @@ H5F__dest(H5F_t *f, hbool_t flush)
/* Mark EOA info dirty in cache, so change will get encoded */
if (H5F_eoa_dirty(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, FAIL, "unable to mark superblock as dirty")
HDONE_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, FAIL, "unable to mark superblock as dirty");
/* Release any space allocated to space aggregators,
* so that the eoa value corresponds to the end of the
@ -1470,12 +1470,12 @@ H5F__dest(H5F_t *f, hbool_t flush)
*/
if (H5MF_free_aggrs(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release file space")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release file space");
/* Truncate the file to the current allocated size */
if (H5FD_truncate(f->shared->lf, TRUE) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "low level truncate failed")
HDONE_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "low level truncate failed");
/* at this point, only the superblock and superblock
* extension should be dirty.
@ -1490,12 +1490,12 @@ H5F__dest(H5F_t *f, hbool_t flush)
if (f->shared->drvinfo)
if (H5AC_unpin_entry(f->shared->drvinfo) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FSPACE, H5E_CANTUNPIN, FAIL, "unable to unpin drvinfo")
HDONE_ERROR(H5E_FSPACE, H5E_CANTUNPIN, FAIL, "unable to unpin drvinfo");
/* Unpin the superblock, since we're about to destroy the cache */
if (H5AC_unpin_entry(f->shared->sblock) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FSPACE, H5E_CANTUNPIN, FAIL, "unable to unpin superblock")
HDONE_ERROR(H5E_FSPACE, H5E_CANTUNPIN, FAIL, "unable to unpin superblock");
f->shared->sblock = NULL;
} /* end if */
@ -1509,7 +1509,7 @@ H5F__dest(H5F_t *f, hbool_t flush)
/* Remove shared file struct from list of open files */
if (H5F__sfile_remove(f->shared) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file");
/* Shutdown the metadata cache */
/* (Flushes any remaining dirty entries, which should only be the
@ -1517,12 +1517,12 @@ H5F__dest(H5F_t *f, hbool_t flush)
*/
if (H5AC_dest(f))
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file");
/* Shutdown the page buffer cache */
if (H5PB_dest(f->shared) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing page buffer cache")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing page buffer cache");
/* Clean up the metadata cache log location string */
if (f->shared->mdc_log_location)
@ -1536,45 +1536,45 @@ H5F__dest(H5F_t *f, hbool_t flush)
/* Free the root group */
if (H5G_root_free(f->shared->root_grp) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file");
f->shared->root_grp = NULL;
} /* end if */
/* Destroy other components of the file */
if (H5F__accum_reset(f->shared, TRUE) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file");
if (H5FO_dest(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file");
f->shared->cwfs = (struct H5HG_heap_t **)H5MM_xfree(f->shared->cwfs);
if (H5G_node_close(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "problems closing file");
/* Destroy file creation properties */
if (H5I_GENPROP_LST != H5I_get_type(f->shared->fcpl_id))
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_BADTYPE, FAIL, "not a property list")
HDONE_ERROR(H5E_FILE, H5E_BADTYPE, FAIL, "not a property list");
if (H5I_dec_ref(f->shared->fcpl_id) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "can't close property list")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "can't close property list");
/* Clean up the cached VOL connector ID & info */
if (f->shared->vol_info)
if (H5VL_free_connector_info(f->shared->vol_id, f->shared->vol_info) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "unable to release VOL connector info object")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "unable to release VOL connector info object");
if (f->shared->vol_id > 0)
if (H5I_dec_ref(f->shared->vol_id) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "can't close VOL connector ID")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "can't close VOL connector ID");
f->shared->vol_cls = NULL;
/* Close the file */
if (H5FD_close(f->shared->lf) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "unable to close file")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "unable to close file");
/* Free mount table */
f->shared->mtab.child = (H5F_mount_t *)H5MM_xfree(f->shared->mtab.child);
@ -1609,16 +1609,16 @@ H5F__dest(H5F_t *f, hbool_t flush)
* and unwrap file VOL object
*/
if (H5CX_get_vol_wrap_ctx((void **)&vol_wrap_ctx) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "can't get VOL object wrap context")
HDONE_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "can't get VOL object wrap context");
if (vol_wrap_ctx && (NULL == H5VL_object_unwrap(f->vol_obj)))
HDONE_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "can't unwrap VOL object")
HDONE_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "can't unwrap VOL object");
if (H5VL_free_object(f->vol_obj) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "unable to free VOL object")
HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "unable to free VOL object");
f->vol_obj = NULL;
}
if (H5FO_top_dest(f) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "problems closing file")
HDONE_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "problems closing file");
f->shared = NULL;
if (ret_value >= 0)
@ -1904,7 +1904,7 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id)
if (H5FD_lock(lf, (hbool_t)((flags & H5F_ACC_RDWR) ? TRUE : FALSE)) < 0) {
/* Locking failed - Closing will remove the lock */
if (H5FD_close(lf) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "unable to close low-level file info")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "unable to close low-level file info");
HGOTO_ERROR(H5E_FILE, H5E_CANTLOCKFILE, NULL, "unable to lock the file")
} /* end if */
@ -1915,7 +1915,7 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id)
* so we have to close lf here before heading to the error handling.
*/
if (H5FD_close(lf) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to close low-level file info")
HDONE_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to close low-level file info");
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to initialize file structure")
} /* end if */
@ -2119,7 +2119,7 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id)
done:
if ((NULL == ret_value) && file)
if (H5F__dest(file, FALSE) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "problems closing file")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "problems closing file");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F_open() */
@ -2174,7 +2174,7 @@ H5F__flush_phase1(H5F_t *f)
/* Flush any cached dataset storage raw data */
if (H5D_flush_all(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush dataset cache")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush dataset cache");
/* Release any space allocated to space aggregators, so that the eoa value
* corresponds to the end of the space written to in the file.
@ -2184,7 +2184,7 @@ H5F__flush_phase1(H5F_t *f)
*/
if (H5MF_free_aggrs(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release file space")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release file space");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F__flush_phase1() */
@ -2211,12 +2211,12 @@ H5F__flush_phase2(H5F_t *f, hbool_t closing)
/* Inform the metadata cache that we are about to flush */
if (H5AC_prep_for_file_flush(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "prep for MDC flush failed")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "prep for MDC flush failed");
/* Flush the entire metadata cache */
if (H5AC_flush(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush metadata cache")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush metadata cache");
#ifdef H5_HAVE_PARALLEL
if (H5F_HAS_FEATURE(f, H5FD_FEAT_HAS_MPI)) {
@ -2232,12 +2232,12 @@ H5F__flush_phase2(H5F_t *f, hbool_t closing)
/* Truncate the file to the current allocated size */
if (H5FD_truncate(f->shared->lf, closing) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "low level truncate failed")
HDONE_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "low level truncate failed");
/* Flush the entire metadata cache again since the EOA could have changed in the truncate call. */
if (H5AC_flush(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush metadata cache")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush metadata cache");
#ifdef H5_HAVE_PARALLEL
if (H5F_HAS_FEATURE(f, H5FD_FEAT_HAS_MPI))
@ -2248,22 +2248,22 @@ H5F__flush_phase2(H5F_t *f, hbool_t closing)
/* Inform the metadata cache that we are done with the flush */
if (H5AC_secure_from_file_flush(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "secure from MDC flush failed")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "secure from MDC flush failed");
/* Flush out the metadata accumulator */
if (H5F__accum_flush(f->shared) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush metadata accumulator")
HDONE_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush metadata accumulator");
/* Flush the page buffer */
if (H5PB_flush(f->shared) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "page buffer flush failed")
HDONE_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "page buffer flush failed");
/* Flush file buffers to disk. */
if (H5FD_flush(f->shared->lf, closing) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "low level flush failed")
HDONE_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "low level flush failed");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F__flush_phase2() */
@ -2290,12 +2290,12 @@ H5F__flush(H5F_t *f)
/* First phase of flushing data */
if (H5F__flush_phase1(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush file data")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush file data");
/* Second phase of flushing data */
if (H5F__flush_phase2(f, FALSE) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush file data")
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush file data");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F__flush() */
@ -2789,7 +2789,7 @@ done:
/* Close the property list */
if (new_fapl_id > 0)
if (H5I_dec_app_ref(new_fapl_id) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, FAIL, "can't close duplicated FAPL")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, FAIL, "can't close duplicated FAPL");
#ifdef H5_HAVE_SYMLINK
if (realname)
realname = (char *)H5MM_xfree(realname);
@ -3850,12 +3850,12 @@ done:
/* Re-enable accumulator */
f->shared->feature_flags |= (unsigned)H5FD_FEAT_ACCUMULATE_METADATA;
if (H5FD_set_feature_flags(f->shared->lf, f->shared->feature_flags) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "can't set feature_flags in VFD")
HDONE_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "can't set feature_flags in VFD");
/* Reset the # of read attempts */
f->shared->read_attempts = H5F_METADATA_READ_ATTEMPTS;
if (H5F_set_retries(f) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "can't set retries and retries_nbins")
HDONE_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "can't set retries and retries_nbins");
/* Un-set H5F_ACC_SWMR_WRITE in shared open flags */
f->shared->flags &= ~H5F_ACC_SWMR_WRITE;
@ -3865,17 +3865,17 @@ done:
/* Mark superblock as dirty */
if (H5F_super_dirty(f) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, FAIL, "unable to mark superblock as dirty")
HDONE_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, FAIL, "unable to mark superblock as dirty");
/* Flush the superblock */
if (H5F_flush_tagged_metadata(f, H5AC__SUPERBLOCK_TAG) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush superblock")
HDONE_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush superblock");
} /* end if */
/* Unlock the file */
if (H5F_USE_FILE_LOCKING(f))
if (H5FD_unlock(f->shared->lf) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTUNLOCKFILE, FAIL, "unable to unlock the file")
HDONE_ERROR(H5E_FILE, H5E_CANTUNLOCKFILE, FAIL, "unable to unlock the file");
/* Free memory */
if (obj_ids)
@ -3891,7 +3891,7 @@ done:
if (obj_apl_ids) {
for (u = 0; u < grp_dset_count; u++)
if (obj_apl_ids[u] != H5P_DEFAULT && obj_apl_ids[u] >= 0 && H5I_dec_ref(obj_apl_ids[u]) < 0)
HDONE_ERROR(H5E_ID, H5E_CANTDEC, FAIL, "decrementing property list ID failed")
HDONE_ERROR(H5E_ID, H5E_CANTDEC, FAIL, "decrementing property list ID failed");
H5MM_xfree(obj_apl_ids);
}
@ -4022,7 +4022,7 @@ H5F_get_file_id(H5VL_object_t *vol_obj, H5I_type_t obj_type, hbool_t app_ref)
done:
/* Reset object wrapping info in API context */
if (vol_wrapper_set && H5VL_reset_vol_wrapper() < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTRESET, H5I_INVALID_HID, "can't reset VOL wrapper info")
HDONE_ERROR(H5E_FILE, H5E_CANTRESET, H5I_INVALID_HID, "can't reset VOL wrapper info");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F_get_file_id() */

4
src/H5Fmount.c
View File

@ -223,11 +223,11 @@ done:
if (ret_value < 0) {
if (mount_point) {
if (H5G_close(mount_point) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, FAIL, "unable to close mounted group")
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, FAIL, "unable to close mounted group");
}
else {
if (H5G_loc_free(&mp_loc) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to free mount location")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to free mount location");
}
}

28
src/H5Fsuper.c
View File

@ -1019,7 +1019,7 @@ done:
/* Release the superblock */
if (sblock && H5AC_unprotect(f, H5AC_SUPERBLOCK, (haddr_t)0, sblock, sblock_flags) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTUNPROTECT, FAIL, "unable to close superblock")
HDONE_ERROR(H5E_FILE, H5E_CANTUNPROTECT, FAIL, "unable to close superblock");
/* If we have failed, make sure no entries are left in the
* metadata cache, so that it can be shut down and discarded.
@ -1028,12 +1028,12 @@ done:
/* Unpin and discard drvinfo cache entry */
if (f->shared->drvinfo) {
if (H5AC_unpin_entry(f->shared->drvinfo) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTUNPIN, FAIL, "unable to unpin driver info")
HDONE_ERROR(H5E_FILE, H5E_CANTUNPIN, FAIL, "unable to unpin driver info");
/* Evict the driver info block from the cache */
if (sblock) {
if (H5AC_expunge_entry(f, H5AC_DRVRINFO, sblock->driver_addr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTEXPUNGE, FAIL, "unable to expunge driver info block")
HDONE_ERROR(H5E_FILE, H5E_CANTEXPUNGE, FAIL, "unable to expunge driver info block");
f->shared->drvinfo = NULL;
}
} /* end if */
@ -1042,11 +1042,11 @@ done:
if (sblock) {
/* Unpin superblock in cache */
if (H5AC_unpin_entry(sblock) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTUNPIN, FAIL, "unable to unpin superblock")
HDONE_ERROR(H5E_FILE, H5E_CANTUNPIN, FAIL, "unable to unpin superblock");
/* Evict the superblock from the cache */
if (H5AC_expunge_entry(f, H5AC_SUPERBLOCK, (haddr_t)0, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTEXPUNGE, FAIL, "unable to expunge superblock")
HDONE_ERROR(H5E_FILE, H5E_CANTEXPUNGE, FAIL, "unable to expunge superblock");
f->shared->sblock = NULL;
} /* end if */
} /* end if */
@ -1445,7 +1445,7 @@ done:
/* Close superblock extension, if it was created */
if (ext_created && H5F__super_ext_close(f, &ext_loc, ext_created) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "unable to close file's superblock extension")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "unable to close file's superblock extension");
/* Cleanup on failure */
if (ret_value < 0) {
@ -1455,11 +1455,11 @@ done:
if (drvinfo_in_cache) {
/* Unpin drvinfo in cache */
if (H5AC_unpin_entry(drvinfo) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTUNPIN, FAIL, "unable to unpin driver info")
HDONE_ERROR(H5E_FILE, H5E_CANTUNPIN, FAIL, "unable to unpin driver info");
/* Evict the driver info block from the cache */
if (H5AC_expunge_entry(f, H5AC_DRVRINFO, sblock->driver_addr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTEXPUNGE, FAIL, "unable to expunge driver info block")
HDONE_ERROR(H5E_FILE, H5E_CANTEXPUNGE, FAIL, "unable to expunge driver info block");
} /* end if */
else
/* Free driver info block */
@ -1472,16 +1472,16 @@ done:
if (sblock_in_cache) {
/* Unpin superblock in cache */
if (H5AC_unpin_entry(sblock) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTUNPIN, FAIL, "unable to unpin superblock")
HDONE_ERROR(H5E_FILE, H5E_CANTUNPIN, FAIL, "unable to unpin superblock");
/* Evict the superblock from the cache */
if (H5AC_expunge_entry(f, H5AC_SUPERBLOCK, (haddr_t)0, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTEXPUNGE, FAIL, "unable to expunge superblock")
HDONE_ERROR(H5E_FILE, H5E_CANTEXPUNGE, FAIL, "unable to expunge superblock");
} /* end if */
else
/* Free superblock */
if (H5F__super_free(sblock) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTFREE, FAIL, "unable to destroy superblock")
HDONE_ERROR(H5E_FILE, H5E_CANTFREE, FAIL, "unable to destroy superblock");
/* Reset variables in file structure */
f->shared->sblock = NULL;
@ -1726,11 +1726,11 @@ done:
/* Close the superblock extension, if it was opened */
if (ext_opened && H5F__super_ext_close(f, &ext_loc, ext_created) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "unable to close file's superblock extension")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "unable to close file's superblock extension");
/* Mark superblock dirty in cache, if superblock extension was created */
if (ext_created && H5AC_mark_entry_dirty(f->shared->sblock) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, FAIL, "unable to mark superblock as dirty")
HDONE_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, FAIL, "unable to mark superblock as dirty");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5F__super_ext_write_msg() */
@ -1802,7 +1802,7 @@ done:
/* Close superblock extension object header, if opened */
if (ext_opened && H5F__super_ext_close(f, &ext_loc, FALSE) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "unable to close file's superblock extension")
HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "unable to close file's superblock extension");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5F__super_ext_remove_msg() */

4
src/H5Fsuper_cache.c
View File

@ -604,7 +604,7 @@ H5F__cache_superblock_deserialize(const void *_image, size_t len, void *_udata,
/* Size check */
if ((size_t)(image - (const uint8_t *)_image) > len)
HDONE_ERROR(H5E_FILE, H5E_BADVALUE, NULL, "bad decoded superblock size")
HDONE_ERROR(H5E_FILE, H5E_BADVALUE, NULL, "bad decoded superblock size");
ret_value = sblock;
@ -612,7 +612,7 @@ done:
/* Release the [possibly partially initialized] superblock on error */
if (!ret_value && sblock)
if (H5F__super_free(sblock) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTFREE, NULL, "unable to destroy superblock data")
HDONE_ERROR(H5E_FILE, H5E_CANTFREE, NULL, "unable to destroy superblock data");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F__cache_superblock_deserialize() */

4
src/H5Ftest.c
View File

@ -103,7 +103,7 @@ H5F__get_sohm_mesg_count_test(hid_t file_id, unsigned type_id, size_t *mesg_coun
done:
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_FILE, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F__get_sohm_mesg_count_test() */
@ -144,7 +144,7 @@ H5F__check_cached_stab_test(hid_t file_id)
done:
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_FILE, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F__check_cached_stab_test() */

12
src/H5G.c
View File

@ -190,7 +190,7 @@ H5G__create_api_common(hid_t loc_id, const char *name, hid_t lcpl_id, hid_t gcpl
done:
if (H5I_INVALID_HID == ret_value)
if (grp && H5VL_group_close(*vol_obj_ptr, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__create_api_common() */
@ -273,7 +273,7 @@ H5Gcreate_async(const char *app_file, const char *app_func, unsigned app_line, h
H5ARG_TRACE9(__func__, "*s*sIui*siiii", app_file, app_func, app_line, loc_id, name, lcpl_id, gcpl_id, gapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref_always_close(ret_value) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on group ID")
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on group ID");
HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -360,7 +360,7 @@ done:
/* Cleanup on failure */
if (H5I_INVALID_HID == ret_value)
if (grp && H5VL_group_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group");
FUNC_LEAVE_API(ret_value)
} /* end H5Gcreate_anon() */
@ -409,7 +409,7 @@ H5G__open_api_common(hid_t loc_id, const char *name, hid_t gapl_id, void **token
done:
if (H5I_INVALID_HID == ret_value)
if (grp && H5VL_group_close(*vol_obj_ptr, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5G__open_api_common() */
@ -482,7 +482,7 @@ H5Gopen_async(const char *app_file, const char *app_func, unsigned app_line, hid
H5ARG_TRACE7(__func__, "*s*sIui*sii", app_file, app_func, app_line, loc_id, name, gapl_id, es_id)) < 0) {
/* clang-format on */
if (H5I_dec_app_ref_always_close(ret_value) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on group ID")
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, H5I_INVALID_HID, "can't decrement count on group ID");
HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, H5I_INVALID_HID, "can't insert token into event set")
} /* end if */
@ -952,7 +952,7 @@ H5Gclose_async(const char *app_file, const char *app_func, unsigned app_line, hi
done:
if (connector && H5VL_conn_dec_rc(connector) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, FAIL, "can't decrement ref count on connector")
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, FAIL, "can't decrement ref count on connector");
FUNC_LEAVE_API(ret_value)
} /* end H5Gclose_async() */

2
src/H5Gcache.c
View File

@ -194,7 +194,7 @@ H5G__cache_node_deserialize(const void *_image, size_t len, void *_udata, hbool_
done:
if (!ret_value)
if (sym && H5G__node_free(sym) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, NULL, "unable to destroy symbol table node")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, NULL, "unable to destroy symbol table node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__cache_node_deserialize() */

8
src/H5Gcompact.c
View File

@ -226,7 +226,7 @@ H5G__compact_get_name_by_idx(const H5O_loc_t *oloc, const H5O_linfo_t *linfo, H5
done:
/* Release link table */
if (ltable.lnks && H5G__link_release_table(&ltable) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__compact_get_name_by_idx() */
@ -343,7 +343,7 @@ H5G__compact_remove_by_idx(const H5O_loc_t *oloc, const H5O_linfo_t *linfo, H5RS
done:
/* Release link table */
if (ltable.lnks && H5G__link_release_table(&ltable) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__compact_remove_by_idx() */
@ -383,7 +383,7 @@ H5G__compact_iterate(const H5O_loc_t *oloc, const H5O_linfo_t *linfo, H5_index_t
done:
/* Release link table */
if (ltable.lnks && H5G__link_release_table(&ltable) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__compact_iterate() */
@ -507,7 +507,7 @@ H5G__compact_lookup_by_idx(const H5O_loc_t *oloc, const H5O_linfo_t *linfo, H5_i
done:
/* Release link table */
if (ltable.lnks && H5G__link_release_table(&ltable) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__compact_lookup_by_idx() */

50
src/H5Gdense.c
View File

@ -322,11 +322,11 @@ H5G__dense_create(H5F_t *f, H5O_linfo_t *linfo, const H5O_pline_t *pline)
done:
/* Close the open objects */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
if (bt2_corder && H5B2_close(bt2_corder) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__dense_create() */
@ -419,13 +419,13 @@ H5G__dense_insert(H5F_t *f, const H5O_linfo_t *linfo, const H5O_link_t *lnk)
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
if (bt2_corder && H5B2_close(bt2_corder) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index");
if (wb && H5WB_unwrap(wb) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close wrapped buffer");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__dense_insert() */
@ -513,9 +513,9 @@ H5G__dense_lookup(H5F_t *f, const H5O_linfo_t *linfo, const char *name, hbool_t
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__dense_lookup() */
@ -683,11 +683,11 @@ H5G__dense_lookup_by_idx(H5F_t *f, const H5O_linfo_t *linfo, H5_index_t idx_type
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index");
if (ltable.lnks && H5G__link_release_table(&ltable) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__dense_lookup_by_idx() */
@ -970,11 +970,11 @@ H5G__dense_iterate(H5F_t *f, const H5O_linfo_t *linfo, H5_index_t idx_type, H5_i
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index");
if (ltable.lnks && H5G__link_release_table(&ltable) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__dense_iterate() */
@ -1159,11 +1159,11 @@ H5G__dense_get_name_by_idx(H5F_t *f, H5O_linfo_t *linfo, H5_index_t idx_type, H5
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index");
if (ltable.lnks && H5G__link_release_table(&ltable) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__dense_get_name_by_idx() */
@ -1223,7 +1223,7 @@ H5G__dense_remove_fh_cb(const void *obj, size_t obj_len, void *_udata)
done:
/* Release resources */
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for creation order index");
if (lnk)
H5O_msg_free(H5O_LINK_ID, lnk);
@ -1321,9 +1321,9 @@ H5G__dense_remove(H5F_t *f, const H5O_linfo_t *linfo, H5RS_str_t *grp_full_path_
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__dense_remove() */
@ -1454,7 +1454,7 @@ H5G__dense_remove_by_idx_bt2_cb(const void *_record, void *_bt2_udata)
done:
/* Release resources */
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for 'other' index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for 'other' index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__dense_remove_by_idx_bt2_cb() */
@ -1555,11 +1555,11 @@ H5G__dense_remove_by_idx(H5F_t *f, const H5O_linfo_t *linfo, H5RS_str_t *grp_ful
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close fractal heap");
if (bt2 && H5B2_close(bt2) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for index");
if (ltable.lnks && H5G__link_release_table(&ltable) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__dense_remove_by_idx() */

6
src/H5Gdeprec.c
View File

@ -222,11 +222,11 @@ H5Gcreate1(hid_t loc_id, const char *name, size_t size_hint)
done:
if (H5I_INVALID_HID != tmp_gcpl && tmp_gcpl != H5P_GROUP_CREATE_DEFAULT)
if (H5I_dec_ref(tmp_gcpl) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release property list")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release property list");
if (H5I_INVALID_HID == ret_value)
if (grp && H5VL_group_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group");
FUNC_LEAVE_API(ret_value)
} /* end H5Gcreate1() */
@ -280,7 +280,7 @@ H5Gopen1(hid_t loc_id, const char *name)
done:
if (H5I_INVALID_HID == ret_value)
if (grp && H5VL_group_close(vol_obj, H5P_DATASET_XFER_DEFAULT, H5_REQUEST_NULL) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release group");
FUNC_LEAVE_API(ret_value)
} /* end H5Gopen1() */

24
src/H5Gint.c
View File

@ -326,11 +326,11 @@ done:
if (oloc_init) {
if (H5O_dec_rc_by_loc(&(grp->oloc)) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, NULL,
"unable to decrement refcount on newly created object")
"unable to decrement refcount on newly created object");
if (H5O_close(&(grp->oloc), NULL) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, NULL, "unable to release object header")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, NULL, "unable to release object header");
if (H5O_delete(file, grp->oloc.addr) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTDELETE, NULL, "unable to delete object header")
HDONE_ERROR(H5E_SYM, H5E_CANTDELETE, NULL, "unable to delete object header");
} /* end if */
if (grp != NULL) {
if (grp->shared != NULL)
@ -395,7 +395,7 @@ H5G__open_name(const H5G_loc_t *loc, const char *name)
done:
if (!ret_value)
if (loc_found && H5G_loc_free(&grp_loc) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, NULL, "can't free location")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, NULL, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__open_name() */
@ -872,10 +872,10 @@ done:
/* Release the group opened */
if (gid != H5I_INVALID_HID) {
if (H5I_dec_app_ref(gid) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to close group")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to close group");
}
else if (grp && H5G_close(grp) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "unable to release group")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "unable to release group");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G_iterate() */
@ -1054,7 +1054,7 @@ done:
/* Release resources */
if (obj_found && H5G_loc_free(&obj_loc) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, H5_ITER_ERROR, "can't free location")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, H5_ITER_ERROR, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__visit_cb() */
@ -1193,10 +1193,10 @@ done:
/* Release the group opened */
if (gid != H5I_INVALID_HID) {
if (H5I_dec_app_ref(gid) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to close group")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to close group");
}
else if (grp && H5G_close(grp) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "unable to release group")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "unable to release group");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G_visit() */
@ -1286,7 +1286,7 @@ done:
if (ret_value < 0) {
if (new_gcpl_id > 0)
if (H5I_dec_app_ref(new_gcpl_id) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, H5I_INVALID_HID, "can't free")
HDONE_ERROR(H5E_SYM, H5E_CANTDEC, H5I_INVALID_HID, "can't free");
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
@ -1333,7 +1333,7 @@ H5G__get_info_by_name(const H5G_loc_t *loc, const char *name, H5G_info_t *grp_in
done:
/* Clean up */
if (loc_found && H5G_loc_free(&grp_loc) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__get_info_by_name() */
@ -1380,7 +1380,7 @@ H5G__get_info_by_idx(const H5G_loc_t *loc, const char *group_name, H5_index_t id
done:
/* Clean up */
if (loc_found && H5G_loc_free(&grp_loc) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__get_info_by_idx() */

2
src/H5Gloc.c
View File

@ -476,7 +476,7 @@ done:
/* Release the object location if we failed after copying it */
if (ret_value < 0 && obj_loc_valid)
if (H5G_loc_free(udata->loc) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't free location");
/* Indicate that this callback didn't take ownership of the group *
* location for the object */

2
src/H5Gname.c
View File

@ -1082,7 +1082,7 @@ H5G__get_name_by_addr_cb(hid_t gid, const char *path, const H5L_info2_t *linfo,
done:
if (obj_found && H5G_loc_free(&obj_loc) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, H5_ITER_ERROR, "can't free location")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, H5_ITER_ERROR, "can't free location");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__get_name_by_addr_cb() */

26
src/H5Gnode.c
View File

@ -497,7 +497,7 @@ H5G__node_found(H5F_t *f, haddr_t addr, const void H5_ATTR_UNUSED *_lt_key, hboo
done:
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to release symbol table node")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to release symbol table node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__node_found() */
@ -656,9 +656,9 @@ H5G__node_insert(H5F_t *f, haddr_t addr, void H5_ATTR_UNUSED *_lt_key, hbool_t H
done:
if (snrt && H5AC_unprotect(f, H5AC_SNODE, *new_node_p, snrt, snrt_flags) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to release symbol table node")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to release symbol table node");
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, sn_flags) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to release symbol table node")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to release symbol table node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__node_insert() */
@ -868,7 +868,7 @@ H5G__node_remove(H5F_t *f, haddr_t addr, void H5_ATTR_NDEBUG_UNUSED *_lt_key /*i
done:
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, sn_flags) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to release symbol table node")
HDONE_ERROR(H5E_SYM, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to release symbol table node");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__node_remove() */
@ -943,7 +943,7 @@ H5G__node_iterate(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr,
done:
/* Release resources */
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__node_iterate() */
@ -983,7 +983,7 @@ H5G__node_sumup(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr,
done:
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__node_sumup() */
@ -1040,7 +1040,7 @@ H5G__node_by_idx(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr,
done:
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__node_by_idx() */
@ -1253,7 +1253,7 @@ H5G__node_copy(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr, const
/* (Don't increment the link count - that's already done above for hard links) */
if (H5G__stab_insert_real(udata->dst_file, udata->dst_stab, name, &lnk, obj_type,
(obj_type == H5O_TYPE_GROUP ? &gcrt_info : NULL)) < 0)
HGOTO_ERROR_TAG(H5E_DATATYPE, H5E_CANTINIT, H5_ITER_ERROR, "unable to insert the name")
HGOTO_ERROR_TAG(H5E_DATATYPE, H5E_CANTINIT, H5_ITER_ERROR, "unable to insert the name");
/* Reset metadata tag */
H5_END_TAG
@ -1262,10 +1262,10 @@ H5G__node_copy(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr, const
done:
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to unprotect symbol name")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to unprotect symbol name");
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__node_copy() */
@ -1337,7 +1337,7 @@ H5G__node_build_table(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr
done:
/* Release the locked items */
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__node_build_table() */
@ -1444,9 +1444,9 @@ H5G_node_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, had
done:
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to release symbol table node")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to release symbol table node");
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G_node_debug() */

8
src/H5Gobj.c
View File

@ -320,7 +320,7 @@ H5G__obj_get_linfo(const H5O_loc_t *grp_oloc, H5O_linfo_t *linfo)
done:
/* Release resources */
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for name index");
FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5G__obj_get_linfo() */
@ -580,7 +580,7 @@ H5G_obj_insert(const H5O_loc_t *grp_oloc, const char *name, H5O_link_t *obj_lnk,
done:
/* Free any space used by the pipeline message */
if (pline && H5O_msg_reset(H5O_PLINE_ID, pline) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "can't release pipeline")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "can't release pipeline");
FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5G_obj_insert() */
@ -722,7 +722,7 @@ H5G__obj_info(const H5O_loc_t *oloc, H5G_info_t *grp_info)
done:
/* Clean up resources */
if (grp && H5G_close(grp) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "unable to close queried group")
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "unable to close queried group");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__obj_info() */
@ -866,7 +866,7 @@ H5G__obj_remove_update_linfo(const H5O_loc_t *oloc, H5O_linfo_t *linfo)
/* Release object header */
if (H5O_unpin(oh) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTUNPIN, FAIL,
"unable to unpin group object header")
"unable to unpin group object header");
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "can't create message")
} /* end if */

10
src/H5Goh.c
View File

@ -202,7 +202,7 @@ H5O__group_open(const H5G_loc_t *obj_loc, H5I_type_t *opened_type)
done:
if (NULL == ret_value)
if (grp && H5G_close(grp) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, NULL, "unable to release group")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, NULL, "unable to release group");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O__group_open() */
@ -247,7 +247,7 @@ H5O__group_create(H5F_t *f, void *_crt_info, H5G_loc_t *obj_loc)
done:
if (ret_value == NULL)
if (grp && H5G_close(grp) < 0)
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, NULL, "unable to release group")
HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, NULL, "unable to release group");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O__group_create() */
@ -370,11 +370,11 @@ H5O__group_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5_ih_info_t *bh_info)
done:
/* Release resources */
if (fheap && H5HF_close(fheap) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close fractal heap")
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close fractal heap");
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree for name index");
if (bt2_corder && H5B2_close(bt2_corder) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree for creation order index");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O__group_bh_info() */

2
src/H5Groot.c
View File

@ -300,7 +300,7 @@ done:
/* Mark superblock dirty in cache, if necessary */
if (sblock_dirty)
if (H5AC_mark_entry_dirty(f->shared->sblock) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, FAIL, "unable to mark superblock as dirty")
HDONE_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, FAIL, "unable to mark superblock as dirty");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G_mkroot() */

22
src/H5Gstab.c
View File

@ -152,7 +152,7 @@ H5G__stab_create_components(H5F_t *f, H5O_stab_t *stab, size_t size_hint)
done:
/* Release resources */
if (heap && FAIL == H5HL_unprotect(heap))
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__stab_create_components() */
@ -260,7 +260,7 @@ H5G__stab_insert_real(H5F_t *f, const H5O_stab_t *stab, const char *name, H5O_li
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__stab_insert_real() */
@ -343,7 +343,7 @@ H5G__stab_remove(const H5O_loc_t *loc, H5RS_str_t *grp_full_path_r, const char *
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__stab_remove() */
@ -397,7 +397,7 @@ H5G__stab_remove_by_idx(const H5O_loc_t *grp_oloc, H5RS_str_t *grp_full_path_r,
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
/* Reset the link information, if we have a copy */
if (lnk_copied)
@ -453,7 +453,7 @@ H5G__stab_delete(H5F_t *f, const H5O_stab_t *stab)
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__stab_delete() */
@ -539,9 +539,9 @@ H5G__stab_iterate(const H5O_loc_t *oloc, H5_iter_order_t order, hsize_t skip, hs
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
if (ltable.lnks && H5G__link_release_table(&ltable) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table")
HDONE_ERROR(H5E_SYM, H5E_CANTFREE, FAIL, "unable to release link table");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__stab_iterate() */
@ -737,7 +737,7 @@ H5G__stab_get_name_by_idx(const H5O_loc_t *oloc, H5_iter_order_t order, hsize_t
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
/* Free the duplicated name */
if (udata_valid && udata.name != NULL)
@ -827,7 +827,7 @@ H5G__stab_lookup(const H5O_loc_t *grp_oloc, const char *name, hbool_t *found, H5
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__stab_lookup() */
@ -931,7 +931,7 @@ H5G__stab_lookup_by_idx(const H5O_loc_t *grp_oloc, H5_iter_order_t order, hsize_
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__stab_lookup_by_idx() */
@ -1009,7 +1009,7 @@ H5G__stab_valid(H5O_loc_t *grp_oloc, H5O_stab_t *alt_stab)
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5G__stab_valid */

36
src/H5Gtest.c
View File

@ -176,7 +176,7 @@ H5G__is_empty_test(hid_t gid)
done:
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5G__is_empty_test() */
@ -243,7 +243,7 @@ H5G__has_links_test(hid_t gid, unsigned *nmsgs)
done:
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5G__has_links_test() */
@ -299,7 +299,7 @@ H5G__has_stab_test(hid_t gid)
done:
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5G__has_stab_test() */
@ -374,7 +374,7 @@ H5G__is_new_dense_test(hid_t gid)
done:
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5G__is_new_dense_test() */
@ -426,33 +426,33 @@ H5G__new_dense_info_test(hid_t gid, hsize_t *name_count, hsize_t *corder_count)
/* Get the link info */
if (H5G__obj_get_linfo(&(grp->oloc), &linfo) < 0)
HGOTO_ERROR_TAG(H5E_SYM, H5E_BADMESG, FAIL, "can't get link info")
HGOTO_ERROR_TAG(H5E_SYM, H5E_BADMESG, FAIL, "can't get link info");
/* Check for 'dense' link storage file addresses being defined */
if (!H5_addr_defined(linfo.fheap_addr))
HGOTO_DONE_TAG(FAIL)
HGOTO_DONE_TAG(FAIL);
if (!H5_addr_defined(linfo.name_bt2_addr))
HGOTO_DONE_TAG(FAIL)
HGOTO_DONE_TAG(FAIL);
/* Open the name index v2 B-tree */
if (NULL == (bt2_name = H5B2_open(grp->oloc.file, linfo.name_bt2_addr, NULL)))
HGOTO_ERROR_TAG(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for name index")
HGOTO_ERROR_TAG(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for name index");
/* Retrieve # of records in name index */
if (H5B2_get_nrec(bt2_name, name_count) < 0)
HGOTO_ERROR_TAG(H5E_SYM, H5E_CANTCOUNT, FAIL, "unable to retrieve # of records from name index")
HGOTO_ERROR_TAG(H5E_SYM, H5E_CANTCOUNT, FAIL, "unable to retrieve # of records from name index");
/* Check if there is a creation order index */
if (H5_addr_defined(linfo.corder_bt2_addr)) {
/* Open the creation order index v2 B-tree */
if (NULL == (bt2_corder = H5B2_open(grp->oloc.file, linfo.corder_bt2_addr, NULL)))
HGOTO_ERROR_TAG(H5E_SYM, H5E_CANTOPENOBJ, FAIL,
"unable to open v2 B-tree for creation order index")
"unable to open v2 B-tree for creation order index");
/* Retrieve # of records in creation order index */
if (H5B2_get_nrec(bt2_corder, corder_count) < 0)
HGOTO_ERROR_TAG(H5E_SYM, H5E_CANTCOUNT, FAIL,
"unable to retrieve # of records from creation order index")
"unable to retrieve # of records from creation order index");
} /* end if */
else
*corder_count = 0;
@ -463,11 +463,11 @@ H5G__new_dense_info_test(hid_t gid, hsize_t *name_count, hsize_t *corder_count)
done:
/* Release resources */
if (bt2_name && H5B2_close(bt2_name) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree for name index")
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree for name index");
if (bt2_corder && H5B2_close(bt2_corder) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree for creation order index")
HDONE_ERROR(H5E_SYM, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree for creation order index");
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5G__new_dense_info_test() */
@ -520,7 +520,7 @@ H5G__lheap_size_test(hid_t gid, size_t *lheap_size)
done:
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5G__lheap_size_test() */
@ -632,7 +632,7 @@ H5G__user_path_test(hid_t obj_id, char *user_path, size_t *user_path_len, unsign
done:
if (api_ctx_pushed && H5CX_pop(FALSE) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context")
HDONE_ERROR(H5E_SYM, H5E_CANTRESET, FAIL, "can't reset API context");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5G__user_path_test() */
@ -683,7 +683,7 @@ H5G__verify_cached_stab_test(H5O_loc_t *grp_oloc, H5G_entry_t *ent)
done:
/* Release resources */
if (heap && H5HL_unprotect(heap) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap");
FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5G__verify_cached_stab_test() */
@ -766,7 +766,7 @@ H5G__verify_cached_stabs_test_cb(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, h
done:
if (sn && H5AC_unprotect(f, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header")
HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5_ITER_ERROR, "unable to release object header");
if (targ_oh) {
assert(ret_value == H5_ITER_ERROR);

10
src/H5Gtraverse.c
View File

@ -238,10 +238,10 @@ H5G__traverse_ud(const H5G_loc_t *grp_loc /*in,out*/, const H5O_link_t *lnk, H5G
done:
/* Close location given to callback. */
if (cur_grp > 0 && H5I_dec_ref(cur_grp) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to close ID for current location")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to close ID for current location");
if (ret_value < 0 && cb_return > 0 && H5I_dec_ref(cb_return) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to close ID from UD callback")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to close ID from UD callback");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__traverse_ud() */
@ -757,11 +757,11 @@ done:
/* If there's valid information in the link, reset it */
if (link_valid)
if (H5O_msg_reset(H5O_LINK_ID, &lnk) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to reset link message")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to reset link message");
/* Release temporary component buffer */
if (wb && H5WB_unwrap(wb) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't release wrapped buffer")
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "can't release wrapped buffer");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5G__traverse_real() */
@ -813,7 +813,7 @@ H5G_traverse(const H5G_loc_t *loc, const char *name, unsigned target, H5G_traver
/* Go perform "real" traversal */
if (H5G__traverse_real(loc, name, target, op, op_data) < 0)
HGOTO_ERROR_TAG(H5E_SYM, H5E_NOTFOUND, FAIL, "internal path traversal failed")
HGOTO_ERROR_TAG(H5E_SYM, H5E_NOTFOUND, FAIL, "internal path traversal failed");
/* Reset tag after traversal */
H5_END_TAG

10
src/H5HF.c
View File

@ -172,10 +172,10 @@ H5HF_create(H5F_t *f, const H5HF_create_t *cparam)
done:
if (hdr && H5AC_unprotect(f, H5AC_FHEAP_HDR, fh_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, NULL, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, NULL, "unable to release fractal heap header");
if (!ret_value && fh)
if (H5HF_close(fh) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTCLOSEOBJ, NULL, "unable to close fractal heap")
HDONE_ERROR(H5E_HEAP, H5E_CANTCLOSEOBJ, NULL, "unable to close fractal heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_create() */
@ -234,10 +234,10 @@ H5HF_open(H5F_t *f, haddr_t fh_addr)
done:
if (hdr && H5AC_unprotect(f, H5AC_FHEAP_HDR, fh_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, NULL, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, NULL, "unable to release fractal heap header");
if (!ret_value && fh)
if (H5HF_close(fh) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTCLOSEOBJ, NULL, "unable to close fractal heap")
HDONE_ERROR(H5E_HEAP, H5E_CANTCLOSEOBJ, NULL, "unable to close fractal heap");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_open() */
@ -865,7 +865,7 @@ H5HF_delete(H5F_t *f, haddr_t fh_addr)
done:
/* Unprotect the header, if an error occurred */
if (hdr && H5AC_unprotect(f, H5AC_FHEAP_HDR, fh_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_delete() */

12
src/H5HFcache.c
View File

@ -553,7 +553,7 @@ H5HF__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, hbool_
done:
if (!ret_value && hdr)
if (H5HF__hdr_free(hdr) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, NULL, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, NULL, "unable to release fractal heap header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF__cache_hdr_deserialize() */
@ -1070,7 +1070,7 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED
done:
if (!ret_value && iblock)
if (H5HF__man_iblock_dest(iblock) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, NULL, "unable to destroy fractal heap indirect block")
HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, NULL, "unable to destroy fractal heap indirect block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF__cache_iblock_deserialize() */
@ -1813,7 +1813,7 @@ done:
/* Cleanup on error */
if (!ret_value && dblock)
if (H5HF__man_dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, NULL, "unable to destroy fractal heap direct block")
HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, NULL, "unable to destroy fractal heap direct block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF__cache_dblock_deserialize() */
@ -2678,7 +2678,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
if (NULL == (root_iblock = (H5HF_indirect_t *)H5AC_protect(
f, H5AC_FHEAP_IBLOCK, root_iblock_addr, NULL, H5AC__READ_ONLY_FLAG)))
HGOTO_ERROR_TAG(H5E_HEAP, H5E_CANTPROTECT, FAIL, "H5AC_protect() failed.")
HGOTO_ERROR_TAG(H5E_HEAP, H5E_CANTPROTECT, FAIL, "H5AC_protect() failed.");
H5_END_TAG
@ -2753,7 +2753,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
if (NULL == (iblock = (H5HF_indirect_t *)H5AC_protect(
f, H5AC_FHEAP_IBLOCK, root_iblock_addr, NULL, H5AC__READ_ONLY_FLAG)))
HGOTO_ERROR_TAG(H5E_HEAP, H5E_CANTPROTECT, FAIL, "H5AC_protect() failed.")
HGOTO_ERROR_TAG(H5E_HEAP, H5E_CANTPROTECT, FAIL, "H5AC_protect() failed.");
H5_END_TAG
@ -3318,7 +3318,7 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5
if (NULL ==
(child_iblock = (H5HF_indirect_t *)H5AC_protect(
f, H5AC_FHEAP_IBLOCK, child_iblock_addr, NULL, H5AC__READ_ONLY_FLAG)))
HGOTO_ERROR_TAG(H5E_HEAP, H5E_CANTPROTECT, FAIL, "H5AC_protect() failed.")
HGOTO_ERROR_TAG(H5E_HEAP, H5E_CANTPROTECT, FAIL, "H5AC_protect() failed.");
H5_END_TAG

12
src/H5HFdbg.c
View File

@ -337,7 +337,7 @@ H5HF_hdr_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth)
done:
if (hdr && H5AC_unprotect(f, H5AC_FHEAP_HDR, addr, hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_hdr_debug() */
@ -531,9 +531,9 @@ H5HF_dblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
done:
if (dblock && H5AC_unprotect(f, H5AC_FHEAP_DBLOCK, addr, dblock, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap direct block")
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap direct block");
if (hdr && H5AC_unprotect(f, H5AC_FHEAP_HDR, hdr_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap header");
H5MM_xfree(marker);
FUNC_LEAVE_NOAPI(ret_value)
@ -695,9 +695,9 @@ H5HF_iblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
done:
if (iblock && H5HF__man_iblock_unprotect(iblock, H5AC__NO_FLAGS_SET, did_protect) < 0)
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap direct block")
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap direct block");
if (hdr && H5AC_unprotect(f, H5AC_FHEAP_HDR, hdr_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_iblock_debug() */
@ -802,7 +802,7 @@ H5HF_sects_debug(H5F_t *f, haddr_t fh_addr, FILE *stream, int indent, int fwidth
done:
if (hdr && H5AC_unprotect(f, H5AC_FHEAP_HDR, fh_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release fractal heap header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_sects_debug() */

4
src/H5HFdblock.c
View File

@ -188,7 +188,7 @@ done:
if (ret_value < 0)
if (dblock)
if (H5HF__man_dblock_dest(dblock) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy fractal heap direct block")
HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy fractal heap direct block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF__man_dblock_create() */
@ -300,7 +300,7 @@ H5HF__man_dblock_destroy(H5HF_hdr_t *hdr, H5HF_direct_t *dblock, haddr_t dblock_
done:
/* Unprotect the indirect block, with appropriate flags */
if (H5AC_unprotect(hdr->f, H5AC_FHEAP_DBLOCK, dblock_addr, dblock, cache_flags) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap direct block")
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap direct block");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF__man_dblock_destroy() */

4
src/H5HFhdr.c
View File

@ -473,7 +473,7 @@ H5HF__hdr_create(H5F_t *f, const H5HF_create_t *cparam)
done:
if (!H5_addr_defined(ret_value) && hdr)
if (H5HF__hdr_free(hdr) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, HADDR_UNDEF, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, HADDR_UNDEF, "unable to release fractal heap header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF__hdr_create() */
@ -1421,7 +1421,7 @@ H5HF__hdr_delete(H5HF_hdr_t *hdr)
done:
/* Unprotect the header with appropriate flags */
if (H5AC_unprotect(hdr->f, H5AC_FHEAP_HDR, hdr->heap_addr, hdr, cache_flags) < 0)
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap header")
HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release fractal heap header");
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF__hdr_delete() */

Some files were not shown because too many files have changed in this diff Show More