unify return values for destroy functions

fixes: #1217

Author: lplewa

include/umf/memory_pool.h

@@ -58,8 +58,9 @@ umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
 ///
 /// @brief Destroys memory pool.
 /// @param hPool handle to the pool
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-void umfPoolDestroy(umf_memory_pool_handle_t hPool);
+umf_result_t umfPoolDestroy(umf_memory_pool_handle_t hPool);
 
 ///
 /// @brief Allocates \p size bytes of uninitialized storage from \p hPool

include/umf/memory_pool_ops.h

@@ -48,7 +48,7 @@ typedef struct umf_memory_pool_ops_t {
     /// @brief Finalizes memory pool
     /// @param pool pool to finalize
     ///
-    void (*finalize)(void *pool);
+    umf_result_t (*finalize)(void *pool);
 
     ///
     /// @brief Allocates \p size bytes of uninitialized storage from \p pool

include/umf/memory_provider.h

@@ -51,8 +51,9 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
 ///
 /// @brief Destroys memory provider.
 /// @param hProvider handle to the memory provider
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider);
+umf_result_t umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider);
 
 ///
 /// @brief Allocates \p size bytes of uninitialized storage from memory \p hProvider

include/umf/memory_provider_ops.h

@@ -43,7 +43,7 @@ typedef struct umf_memory_provider_ops_t {
     /// @brief Finalizes memory provider.
     /// @param provider provider to finalize
     ///
-    void (*finalize)(void *provider);
+    umf_result_t (*finalize)(void *provider);
 
     ///
     /// @brief Allocates \p size bytes of uninitialized storage from memory \p provider

include/umf/memspace.h

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -58,8 +58,9 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
 ///
 /// \brief Destroys memspace
 /// \param hMemspace handle to memspace
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-void umfMemspaceDestroy(umf_memspace_handle_t hMemspace);
+umf_result_t umfMemspaceDestroy(umf_memspace_handle_t hMemspace);
 
 ///
 /// \brief Retrieves predefined host all memspace.

include/umf/pools/pool_disjoint.h

@@ -35,7 +35,8 @@ umfDisjointPoolSharedLimitsCreate(size_t MaxSize);
 
 /// @brief Destroy previously created pool limits struct.
 /// @param hSharedLimits handle to the shared limits struct.
-void umfDisjointPoolSharedLimitsDestroy(
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDisjointPoolSharedLimitsDestroy(
     umf_disjoint_pool_shared_limits_handle_t hSharedLimits);
 
 /// @brief  Create a struct to store parameters of disjoint pool.

src/memory_pool.c

@@ -201,24 +201,31 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
     return ret;
 }
 
-void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
+umf_result_t umfPoolDestroy(umf_memory_pool_handle_t hPool) {
     if (umf_ba_global_is_destroyed()) {
-        return;
+        return UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    hPool->ops.finalize(hPool->pool_priv);
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    if (hPool->ops.finalize(hPool->pool_priv) != UMF_RESULT_SUCCESS) {
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+    }
 
     umf_memory_provider_handle_t hUpstreamProvider = NULL;
     umfPoolGetMemoryProvider(hPool, &hUpstreamProvider);
 
     if (!(hPool->flags & UMF_POOL_CREATE_FLAG_DISABLE_TRACKING)) {
         // Destroy tracking provider.
-        umfMemoryProviderDestroy(hPool->provider);
+        if (umfMemoryProviderDestroy(hPool->provider) != UMF_RESULT_SUCCESS) {
+            ret = UMF_RESULT_ERROR_UNKNOWN;
+        }
     }
 
     if (hPool->flags & UMF_POOL_CREATE_FLAG_OWN_PROVIDER) {
         // Destroy associated memory provider.
-        umfMemoryProviderDestroy(hUpstreamProvider);
+        if (umfMemoryProviderDestroy(hUpstreamProvider) != UMF_RESULT_SUCCESS) {
+            ret = UMF_RESULT_ERROR_UNKNOWN;
+        }
     }
 
     utils_mutex_destroy_not_free(&hPool->lock);
@@ -227,6 +234,7 @@ void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
 
     // TODO: this free keeps memory in base allocator, so it can lead to OOM in some scenarios (it should be optimized)
     umf_ba_global_free(hPool);
+    return ret;
 }
 
 umf_result_t umfFree(void *ptr) {

src/memory_provider.c

@@ -235,11 +235,18 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
     return UMF_RESULT_SUCCESS;
 }
 
-void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider) {
-    if (hProvider && !umf_ba_global_is_destroyed()) {
-        hProvider->ops.finalize(hProvider->provider_priv);
-        umf_ba_global_free(hProvider);
+umf_result_t umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider) {
+    if (umf_ba_global_is_destroyed()) {
+        return UMF_RESULT_ERROR_UNKNOWN;
     }
+
+    if (!hProvider) {
+        return UMF_RESULT_SUCCESS;
+    }
+
+    umf_result_t ret = hProvider->ops.finalize(hProvider->provider_priv);
+    umf_ba_global_free(hProvider);
+    return ret;
 }
 
 static void

src/memspace.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -130,14 +130,15 @@ umf_result_t umfMemspaceNew(umf_memspace_handle_t *hMemspace) {
     return UMF_RESULT_SUCCESS;
 }
 
-void umfMemspaceDestroy(umf_memspace_handle_t memspace) {
+umf_result_t umfMemspaceDestroy(umf_memspace_handle_t memspace) {
     assert(memspace);
     for (size_t i = 0; i < memspace->size; i++) {
         umfMemtargetDestroy(memspace->nodes[i]);
     }
 
     umf_ba_global_free(memspace->nodes);
     umf_ba_global_free(memspace);
+    return UMF_RESULT_SUCCESS;
 }
 
 umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,

src/pool/pool_disjoint.c

@@ -995,9 +995,9 @@ umf_result_t disjoint_pool_get_last_allocation_error(void *pool) {
 }
 
 // Define destructor for use with unique_ptr
-void disjoint_pool_finalize(void *pool) {
+umf_result_t disjoint_pool_finalize(void *pool) {
     disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
-
+    umf_result_t ret = UMF_RESULT_SUCCESS;
     if (hPool->params.pool_trace > 1) {
         disjoint_pool_print_stats(hPool);
     }
@@ -1008,10 +1008,15 @@ void disjoint_pool_finalize(void *pool) {
 
     VALGRIND_DO_DESTROY_MEMPOOL(hPool);
 
-    umfDisjointPoolSharedLimitsDestroy(hPool->default_shared_limits);
+    if (umfDisjointPoolSharedLimitsDestroy(hPool->default_shared_limits) !=
+        UMF_RESULT_SUCCESS) {
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        LOG_ERR("umfDisjointPoolSharedLimitsDestroy failed");
+    }
     critnib_delete(hPool->known_slabs);
 
     umf_ba_global_free(hPool);
+    return ret;
 }
 
 const char *disjoint_pool_get_name(void *pool) {
@@ -1053,9 +1058,10 @@ umfDisjointPoolSharedLimitsCreate(size_t max_size) {
     return ptr;
 }
 
-void umfDisjointPoolSharedLimitsDestroy(
-    umf_disjoint_pool_shared_limits_t *limits) {
+umf_result_t
+umfDisjointPoolSharedLimitsDestroy(umf_disjoint_pool_shared_limits_t *limits) {
     umf_ba_global_free(limits);
+    return UMF_RESULT_SUCCESS;
 }
 
 umf_result_t