Fix problem with freeing memory in proxy lib

- make sure base_alloc dtor is only called once by adding a macro
  to skip the dtor (it's set in proxy lib).

  Previously, since base_alloc was linked with both libumf and
  proxy_lib, it was called twice and the first time was BEFORE
  the libumf dtor (hence some allocations were still unfreed).

Author: igchor

src/base_alloc/base_alloc.c

@@ -238,13 +238,6 @@ void umf_ba_free(umf_ba_pool_t *pool, void *ptr) {
 }
 
 void umf_ba_destroy(umf_ba_pool_t *pool) {
-    // Do not destroy if we are running in the proxy library,
-    // because it may need those resources till
-    // the very end of exiting the application.
-    if (pool->metadata.n_allocs && is_running_in_proxy_lib()) {
-        return;
-    }
-
 #ifndef NDEBUG
     ba_debug_checks(pool);
     if (pool->metadata.n_allocs) {

src/base_alloc/base_alloc_linux.c

@@ -24,9 +24,11 @@ static size_t Page_size;
 // as the first one and the destructor as the last one in order to avoid use-after-free.
 void __attribute__((constructor(101))) umf_ba_constructor(void) {}
 
+#ifndef SKIP_BASE_ALLOC_DTOR
 void __attribute__((destructor(101))) umf_ba_destructor(void) {
     umf_ba_destroy_global();
 }
+#endif
 
 void *ba_os_alloc(size_t size) {
     return mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
@@ -35,8 +37,7 @@ void *ba_os_alloc(size_t size) {
 
 void ba_os_free(void *ptr, size_t size) {
     int ret = munmap(ptr, size);
-    // TODO: this might fail in proxy_lib
-    // assert(ret == 0);
+    assert(ret == 0);
     (void)ret; // unused
 }
 

src/libumf_linux.c

@@ -15,11 +15,11 @@
 
 umf_memory_tracker_handle_t TRACKER = NULL;
 
-void __attribute__((constructor)) umfCreate(void) {
+void __attribute__((constructor(102))) umfCreate(void) {
     TRACKER = umfMemoryTrackerCreate();
 }
 
-void __attribute__((destructor)) umfDestroy(void) {
+void __attribute__((destructor(102))) umfDestroy(void) {
     umf_memory_tracker_handle_t t = TRACKER;
     // make sure TRACKER is not used after being destroyed
     TRACKER = NULL;

src/provider/provider_tracking.c

@@ -361,20 +361,18 @@ static void check_if_tracker_is_empty(umf_memory_tracker_handle_t hTracker,
         // Do not assert if we are running in the proxy library,
         // because it may need those resources till
         // the very end of exiting the application.
-        if (!is_running_in_proxy_lib()) {
-            if (pool) {
-                fprintf(stderr,
-                        "ASSERT: tracking provider of pool %p is not empty! "
-                        "(%zu items left)\n",
-                        (void *)pool, n_items);
-            } else {
-                fprintf(stderr,
-                        "ASSERT: tracking provider is not empty! (%zu items "
-                        "left)\n",
-                        n_items);
-            }
-            assert(n_items == 0);
+        if (pool) {
+            fprintf(stderr,
+                    "ASSERT: tracking provider of pool %p is not empty! "
+                    "(%zu items left)\n",
+                    (void *)pool, n_items);
+        } else {
+            fprintf(stderr,
+                    "ASSERT: tracking provider is not empty! (%zu items "
+                    "left)\n",
+                    n_items);
         }
+        assert(n_items == 0);
     }
 }
 #endif /* NDEBUG */
@@ -511,13 +509,6 @@ void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
         return;
     }
 
-    // Do not destroy if we are running in the proxy library,
-    // because it may need those resources till
-    // the very end of exiting the application.
-    if (is_running_in_proxy_lib()) {
-        return;
-    }
-
 #ifndef NDEBUG
     check_if_tracker_is_empty(handle, NULL);
 #endif /* NDEBUG */

src/proxy_lib/CMakeLists.txt

@@ -39,9 +39,9 @@ add_umf_library(NAME umf_proxy
 add_library(${PROJECT_NAME}::proxy ALIAS umf_proxy)
 
 if(PROXY_LIB_USES_SCALABLE_POOL)
-    target_compile_definitions(umf_proxy PRIVATE PROXY_LIB_USES_SCALABLE_POOL=1)
+    target_compile_definitions(umf_proxy PRIVATE PROXY_LIB_USES_SCALABLE_POOL=1 SKIP_BASE_ALLOC_DTOR=1)
 elseif(PROXY_LIB_USES_JEMALLOC_POOL)
-    target_compile_definitions(umf_proxy PRIVATE PROXY_LIB_USES_JEMALLOC_POOL=1)
+    target_compile_definitions(umf_proxy PRIVATE PROXY_LIB_USES_JEMALLOC_POOL=1 SKIP_BASE_ALLOC_DTOR=1)
 endif()
 
 target_include_directories(umf_proxy PUBLIC

src/proxy_lib/proxy_lib.c

@@ -93,13 +93,12 @@ void proxy_lib_create_common(void) {
 }
 
 void proxy_lib_destroy_common(void) {
+
     umfPoolDestroy(Proxy_pool);
     Proxy_pool = NULL;
 
     umfMemoryProviderDestroy(OS_memory_provider);
     OS_memory_provider = NULL;
-
-    umf_ba_destroy_global();
 }
 
 /*****************************************************************************/

src/proxy_lib/proxy_lib_linux.c

@@ -9,15 +9,14 @@
 
 #include "proxy_lib.h"
 
-// The priority 102 is used, because the constructor should be called as the second one
-// (just after the first constructor of the base allocator with priority 101)
-// and the destructor as the last but one (just before the last destructor
-// of the base allocator with priority 101), because this library
-// provides the memory allocation API.
-void __attribute__((constructor(102))) proxy_lib_create(void) {
+// Priority forces this ctor to be called after both libumf and
+// base_alloc ctors were called
+void __attribute__((constructor(103))) proxy_lib_create(void) {
     proxy_lib_create_common();
 }
 
-void __attribute__((destructor(102))) proxy_lib_destroy(void) {
+// Priority forces this dtor to be called before both libumf and
+// base_alloc dtors were called
+void __attribute__((destructor(103))) proxy_lib_destroy(void) {
     proxy_lib_destroy_common();
 }

src/utils/utils_common.h

@@ -65,18 +65,6 @@ static inline size_t util_get_page_size(void) { return sysconf(_SC_PAGE_SIZE); }
 
 #endif /* _WIN32 */
 
-// check if we are running in the proxy library
-static inline int is_running_in_proxy_lib(void) {
-    int is_in_proxy_lib_val = 0;
-    char *ld_preload = util_getenv("LD_PRELOAD");
-    if (ld_preload && strstr(ld_preload, "libumf_proxy.so")) {
-        is_in_proxy_lib_val = 1;
-    }
-
-    util_free_getenv(ld_preload);
-    return is_in_proxy_lib_val;
-}
-
 #define NOFUNCTION                                                             \
     do {                                                                       \
     } while (0)