Replace system allocator with the second instance of linear BA

Signed-off-by: Lukasz Dorau <[email protected]>

Author: ldorau

src/proxy_lib/proxy_lib.c

@@ -34,15 +34,17 @@
 
 /*
  * The UMF proxy library uses three memory allocators:
- * 1) the internal linear base allocator (LBA) based on the anonymous mapped memory
- * 2) the system allocator (libc malloc on Linux for example)
+ * 1) the first "LEAK" instance of the internal linear base allocator
+ *    based on the anonymous mapped memory that will NOT be destroyed (with API ba_leak_*()).
+ * 2) the second instance of the internal linear base allocator
+ *    based on the anonymous mapped memory that will be destroyed (with API ba_*()).
  * 3) the main one - UMF pool allocator.
  *
  * Ad 1)
- * The internal linear base allocator (LBA) is used from the very beginning
- * to the start of the constructor of the proxy library to allocate memory
- * for OS specific structures used during loading and starting applications
- * (for example _dl_init() and _dl_fini() on Linux storing arrays of all
+ * The first "LEAK" instance of the internal linear base allocator is used
+ * from the very beginning to the start of the constructor of the proxy library
+ * to allocate memory for OS specific structures used during loading and starting
+ * applications (for example _dl_init() and _dl_fini() on Linux storing arrays of all
  * constructors and destructors that have to be called). That memory will be leaked
  * on purpose (we believe OS will free it), because we cannot free the memory
  * containing array of destructors that have to be called at the end.
@@ -53,19 +55,21 @@
  * - malloc(72704)
  *
  * Ad 2)
- * The system allocator is used from the start of the constructor of the proxy library
- * to the creation of a UMF pool to allocate memory needed by umfMemoryProviderCreate()
- * and umfPoolCreate(). It will be freed by the system allocator.
+ * The second instance of the internal linear base allocator is used
+ * from the start of the constructor of the proxy library to the creation of a UMF pool
+ * to allocate memory needed by umfMemoryProviderCreate() and umfPoolCreate().
+ * It is created at the start of the constructor of the proxy library
+ * and destroyed at the end of the destructor of the proxy library.
  *
  * Ad 3)
  * The UMF pool allocator (the main one) is used from the creation to the destruction
  * of a UMF pool to allocate memory needed by an application. It should be freed
  * by an application.
  */
 
-static UTIL_ONCE_FLAG Base_alloc_initialized = UTIL_ONCE_FLAG_INIT;
-static UTIL_ONCE_FLAG alloc_hooks_are_initialized = UTIL_ONCE_FLAG_INIT;
+static UTIL_ONCE_FLAG Base_alloc_leak_initialized = UTIL_ONCE_FLAG_INIT;
 
+static umf_ba_linear_pool_t *Base_alloc_leak = NULL;
 static umf_ba_linear_pool_t *Base_alloc = NULL;
 static int Constructors_started = 0;
 static umf_memory_provider_handle_t OS_memory_provider = NULL;
@@ -74,17 +78,17 @@ static umf_memory_pool_handle_t Proxy_pool = NULL;
 // it protects us from recursion in umfPool*()
 static __TLS int was_called_from_umfPool = 0;
 
-malloc_func_t System_malloc_func;
-calloc_func_t System_calloc_func;
-realloc_func_t System_realloc_func;
-free_func_t System_free_func;
-aligned_alloc_func_t System_aligned_alloc_func;
-
 /*****************************************************************************/
 /*** The constructor and destructor of the proxy library *********************/
 /*****************************************************************************/
 
+static void ba_create(void);
+static void ba_destroy(void);
+
 void proxy_lib_create_common(void) {
+    // create the second instance of linear base allocator
+    ba_create();
+
     // The constructors of libraries were started. Stop using the linear base
     // allocator that does not free the memory (we leak it on purpose in order
     // to not free the memory used by _dl_fini() containing a map (array)
@@ -117,41 +121,28 @@ void proxy_lib_destroy_common(void) {
     Proxy_pool = NULL;
     umfPoolDestroy(pool);
     umfMemoryProviderDestroy(OS_memory_provider);
+    ba_destroy();
 }
 
 /*****************************************************************************/
-/*** The linear base allocator functions *************************************/
+/*** Generic version of realloc() of linear base allocator *******************/
 /*****************************************************************************/
 
-static void proxy_lib_ba_init(void) { Base_alloc = umf_ba_linear_create(0); }
-
-static inline void *ba_malloc(size_t size) {
-    util_init_once(&Base_alloc_initialized, proxy_lib_ba_init);
-    return umf_ba_linear_alloc(Base_alloc, size);
-}
-
-static inline void *ba_calloc(size_t nmemb, size_t size) {
-    util_init_once(&Base_alloc_initialized, proxy_lib_ba_init);
-    // umf_ba_linear_alloc() returns zeroed memory
-    return umf_ba_linear_alloc(Base_alloc, nmemb * size);
-}
-
-static inline void *ba_realloc(void *ptr, size_t size) {
-    util_init_once(&Base_alloc_initialized, proxy_lib_ba_init);
-
+static void *ba_generic_realloc(umf_ba_linear_pool_t *pool, void *ptr,
+                                size_t size) {
     if (size == 0) {
-        // it means free(ptr), but this BA does not free the memory
+        // it means free(ptr), but linear base allocator does not implement free()
         return NULL;
     }
 
     if (ptr == NULL) {
-        return umf_ba_linear_alloc(Base_alloc, size);
+        return umf_ba_linear_alloc(pool, size);
     }
 
-    size_t max_size = umf_ba_linear_pool_contains_pointer(Base_alloc, ptr);
+    size_t max_size = umf_ba_linear_pool_contains_pointer(pool, ptr);
     assert(max_size > 0); // assert that pool contains the pointer
 
-    void *new_ptr = umf_ba_linear_alloc(Base_alloc, size);
+    void *new_ptr = umf_ba_linear_alloc(pool, size);
     if (!new_ptr) {
         return NULL;
     }
@@ -165,42 +156,70 @@ static inline void *ba_realloc(void *ptr, size_t size) {
     return new_ptr;
 }
 
-static inline void *ba_aligned_alloc(size_t alignment, size_t size) {
-    util_init_once(&Base_alloc_initialized, proxy_lib_ba_init);
-    void *ptr = umf_ba_linear_alloc(Base_alloc, size + alignment);
+/*****************************************************************************/
+/*** The LEAK linear base allocator functions ********************************/
+/*****************************************************************************/
+
+static void ba_leak_create(void) { Base_alloc_leak = umf_ba_linear_create(0); }
+
+// it does not implement destroy(), because it will not free memory at all
+
+static inline void *ba_leak_malloc(size_t size) {
+    util_init_once(&Base_alloc_leak_initialized, ba_leak_create);
+    return umf_ba_linear_alloc(Base_alloc_leak, size);
+}
+
+static inline void *ba_leak_calloc(size_t nmemb, size_t size) {
+    util_init_once(&Base_alloc_leak_initialized, ba_leak_create);
+    // umf_ba_linear_alloc() returns zeroed memory
+    return umf_ba_linear_alloc(Base_alloc_leak, nmemb * size);
+}
+
+static inline void *ba_leak_realloc(void *ptr, size_t size) {
+    util_init_once(&Base_alloc_leak_initialized, ba_leak_create);
+    return ba_generic_realloc(Base_alloc_leak, ptr, size);
+}
+
+static inline void *ba_leak_aligned_alloc(size_t alignment, size_t size) {
+    util_init_once(&Base_alloc_leak_initialized, ba_leak_create);
+    void *ptr = umf_ba_linear_alloc(Base_alloc_leak, size + alignment);
     return (void *)ALIGN_UP((uintptr_t)ptr, alignment);
 }
 
 /*****************************************************************************/
-/*** The system allocator functions ******************************************/
+/*** The second instance of linear base allocator functions ******************/
 /*****************************************************************************/
 
-static inline void *system_malloc(size_t size) {
-    util_init_once(&alloc_hooks_are_initialized, proxy_lib_system_alloc_init);
-    return System_malloc_func(size);
+static void ba_create(void) {
+    assert(Base_alloc == NULL);
+    Base_alloc = umf_ba_linear_create(0);
+    assert(Base_alloc);
 }
 
-static inline void *system_calloc(size_t nmemb, size_t size) {
-    util_init_once(&alloc_hooks_are_initialized, proxy_lib_system_alloc_init);
-    return System_calloc_func(nmemb, size);
+static void ba_destroy(void) {
+    if (Base_alloc) {
+        umf_ba_linear_pool_t *pool = Base_alloc;
+        Base_alloc = NULL;
+        umf_ba_linear_destroy(pool);
+    }
+}
+
+static inline void *ba_malloc(size_t size) {
+    return umf_ba_linear_alloc(Base_alloc, size);
 }
 
-static inline void *system_realloc(void *ptr, size_t size) {
-    util_init_once(&alloc_hooks_are_initialized, proxy_lib_system_alloc_init);
-    return System_realloc_func(ptr, size);
+static inline void *ba_calloc(size_t nmemb, size_t size) {
+    // umf_ba_linear_alloc() returns zeroed memory
+    return umf_ba_linear_alloc(Base_alloc, nmemb * size);
 }
 
-static inline void system_free(void *ptr) {
-    util_init_once(&alloc_hooks_are_initialized, proxy_lib_system_alloc_init);
-    System_free_func(ptr);
+static inline void *ba_realloc(void *ptr, size_t size) {
+    return ba_generic_realloc(Base_alloc, ptr, size);
 }
 
-static inline void *system_aligned_alloc(size_t alignment, size_t size) {
-    util_init_once(&alloc_hooks_are_initialized, proxy_lib_system_alloc_init);
-    if (!System_aligned_alloc_func) {
-        return NULL; // unsupported
-    }
-    return System_aligned_alloc_func(alignment, size);
+static inline void *ba_aligned_alloc(size_t alignment, size_t size) {
+    void *ptr = umf_ba_linear_alloc(Base_alloc, size + alignment);
+    return (void *)ALIGN_UP((uintptr_t)ptr, alignment);
 }
 
 /*****************************************************************************/
@@ -216,10 +235,10 @@ void *malloc(size_t size) {
     }
 
     if (Constructors_started) {
-        return system_malloc(size);
+        return ba_malloc(size);
     }
 
-    return ba_malloc(size);
+    return ba_leak_malloc(size);
 }
 
 void *calloc(size_t nmemb, size_t size) {
@@ -231,10 +250,10 @@ void *calloc(size_t nmemb, size_t size) {
     }
 
     if (Constructors_started) {
-        return system_calloc(nmemb, size);
+        return ba_calloc(nmemb, size);
     }
 
-    return ba_calloc(nmemb, size);
+    return ba_leak_calloc(nmemb, size);
 }
 
 void *realloc(void *ptr, size_t size) {
@@ -246,10 +265,10 @@ void *realloc(void *ptr, size_t size) {
     }
 
     if (Constructors_started) {
-        return system_realloc(ptr, size);
+        return ba_realloc(ptr, size);
     }
 
-    return ba_realloc(ptr, size);
+    return ba_leak_realloc(ptr, size);
 }
 
 void free(void *ptr) {
@@ -267,9 +286,8 @@ void free(void *ptr) {
         return;
     }
 
-    if (Constructors_started) {
-        system_free(ptr);
-    }
+    // 1) allocations from the second linear base allocator will be freed by ba_destroy().
+    // 2) allocations from the leak linear base allocator will not be freed at all.
 
     return;
 }
@@ -283,10 +301,10 @@ void *aligned_alloc(size_t alignment, size_t size) {
     }
 
     if (Constructors_started) {
-        return system_aligned_alloc(alignment, size);
+        return ba_aligned_alloc(alignment, size);
     }
 
-    return ba_aligned_alloc(alignment, size);
+    return ba_leak_aligned_alloc(alignment, size);
 }
 
 size_t malloc_usable_size(void *ptr) {

src/proxy_lib/proxy_lib.h

@@ -14,21 +14,8 @@
 extern "C" {
 #endif
 
-typedef void *(*malloc_func_t)(size_t size);
-typedef void *(*calloc_func_t)(size_t nmemb, size_t size);
-typedef void *(*realloc_func_t)(void *ptr, size_t size);
-typedef void (*free_func_t)(void *ptr);
-typedef void *(*aligned_alloc_func_t)(size_t alignment, size_t size);
-
-extern malloc_func_t System_malloc_func;
-extern calloc_func_t System_calloc_func;
-extern realloc_func_t System_realloc_func;
-extern free_func_t System_free_func;
-extern aligned_alloc_func_t System_aligned_alloc_func;
-
 void proxy_lib_create_common(void);
 void proxy_lib_destroy_common(void);
-void proxy_lib_system_alloc_init(void);
 
 #ifdef __cplusplus
 }

src/proxy_lib/proxy_lib_linux.c

@@ -27,20 +27,3 @@ void __attribute__((constructor(102))) proxy_lib_create(void) {
 void __attribute__((destructor(102))) proxy_lib_destroy(void) {
     proxy_lib_destroy_common();
 }
-
-void proxy_lib_system_alloc_init(void) {
-    // ISO C forbids conversion of object pointer to function pointer type [-Werror=pedantic]
-    *((void **)(&System_malloc_func)) = dlsym(RTLD_NEXT, "malloc");
-    *((void **)(&System_calloc_func)) = dlsym(RTLD_NEXT, "calloc");
-    *((void **)(&System_realloc_func)) = dlsym(RTLD_NEXT, "realloc");
-    *((void **)(&System_free_func)) = dlsym(RTLD_NEXT, "free");
-    *((void **)(&System_aligned_alloc_func)) =
-        dlsym(RTLD_NEXT, "aligned_alloc");
-
-    // System_aligned_alloc_func can be NULL
-    if (!System_malloc_func || !System_calloc_func || !System_realloc_func ||
-        !System_free_func) {
-        fprintf(stderr, "error: cannot find libc alloc functions\n");
-        exit(-1);
-    }
-}

src/proxy_lib/proxy_lib_windows.c

@@ -25,23 +25,3 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
     }
     return TRUE;
 }
-
-void proxy_lib_system_alloc_init(void) {
-    /* there is a memleak here, we should unload this library in the destructor but there is no such thing */
-    HMODULE mod = LoadLibrary(TEXT("msvcrt.dll"));
-
-    // ISO C forbids conversion of object pointer to function pointer type [-Werror=pedantic]
-    *((void **)(&System_malloc_func)) = GetProcAddress(mod, "malloc");
-    *((void **)(&System_calloc_func)) = GetProcAddress(mod, "calloc");
-    *((void **)(&System_realloc_func)) = GetProcAddress(mod, "realloc");
-    *((void **)(&System_free_func)) = GetProcAddress(mod, "free");
-    *((void **)(&System_aligned_alloc_func)) =
-        GetProcAddress(mod, "aligned_alloc");
-
-    // System_aligned_alloc_func can be NULL
-    if (!System_malloc_func || !System_calloc_func || !System_realloc_func ||
-        !System_free_func) {
-        fprintf(stderr, "error: cannot find libc alloc functions\n");
-        exit(-1);
-    }
-}