fix memory provider cleanup on initialization failures

Author: bratpiorka

src/memory_provider.c

@@ -360,6 +360,11 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
     ret = provider->ops.get_name(provider->provider_priv, &pname);
     if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("Failed to get pool name");
+        umf_result_t finalize_ret =
+            provider->ops.finalize(provider->provider_priv);
+        if (finalize_ret != UMF_RESULT_SUCCESS) {
+            LOG_ERR("Failed to finalize provider after create failure");
+        }
         umf_ba_global_free(provider);
         return ret;
     }
@@ -373,6 +378,11 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
     ret = umfProviderPostInitialize(&provider->ops, provider_priv);
     if (ret != UMF_RESULT_SUCCESS && ret != UMF_RESULT_ERROR_INVALID_CTL_PATH) {
         LOG_ERR("Failed to post-initialize provider");
+        umf_result_t finalize_ret =
+            provider->ops.finalize(provider->provider_priv);
+        if (finalize_ret != UMF_RESULT_SUCCESS) {
+            LOG_ERR("Failed to finalize provider after create failure");
+        }
         umf_ba_global_free(provider);
         return ret;
     }

test/memoryProviderAPI.cpp

@@ -363,6 +363,66 @@ TEST_P(providerInitializeTest, errorPropagation) {
     ASSERT_EQ(ret, this->GetParam());
 }
 
+static int *provider_destroy_count_ptr = nullptr;
+
+TEST_F(test, memoryProviderCreateCleansUpWhenGetNameFails) {
+    int provider_destroy_count = 0;
+
+    struct provider_fail_get_name : public umf_test::provider_base_t {
+        ~provider_fail_get_name() override { (*provider_destroy_count_ptr)++; }
+
+        umf_result_t get_name(const char **) noexcept {
+            return UMF_RESULT_ERROR_UNKNOWN;
+        }
+    };
+
+    provider_destroy_count_ptr = &provider_destroy_count;
+
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<provider_fail_get_name, void>();
+
+    umf_memory_provider_handle_t hProvider = nullptr;
+    auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
+
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_UNKNOWN);
+    ASSERT_EQ(hProvider, nullptr);
+    ASSERT_EQ(provider_destroy_count, 1);
+    provider_destroy_count_ptr = nullptr;
+}
+
+TEST_F(test, memoryProviderCreateCleansUpWhenPostInitializeFails) {
+    int provider_destroy_count = 0;
+
+    struct provider_fail_post_initialize : public umf_test::provider_base_t {
+        ~provider_fail_post_initialize() override {
+            (*provider_destroy_count_ptr)++;
+        }
+
+        umf_result_t ext_ctl(umf_ctl_query_source_t, const char *name, void *,
+                             size_t, umf_ctl_query_type_t,
+                             va_list) noexcept {
+            if (name && std::string(name) == "post_initialize") {
+                return UMF_RESULT_ERROR_UNKNOWN;
+            }
+
+            return UMF_RESULT_ERROR_INVALID_CTL_PATH;
+        }
+    };
+
+    provider_destroy_count_ptr = &provider_destroy_count;
+
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<provider_fail_post_initialize, void>();
+
+    umf_memory_provider_handle_t hProvider = nullptr;
+    auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
+
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_UNKNOWN);
+    ASSERT_EQ(hProvider, nullptr);
+    ASSERT_EQ(provider_destroy_count, 1);
+    provider_destroy_count_ptr = nullptr;
+}
+
 // This fixture can be instantiated with any function that accepts void
 // and returns any of the results listed inside the variant type.
 struct providerHandleCheck