Fix: libc wrapper: use initial-exec for malloc_nesting TLS

[lttng-ust.git] / liblttng-ust-libc-wrapper / lttng-ust-malloc.c

diff --git a/liblttng-ust-libc-wrapper/lttng-ust-malloc.c b/liblttng-ust-libc-wrapper/lttng-ust-malloc.c
index 771d8382c50eabfe1c47160360601ee2333c6571..84641ddaebcf2d2dfbe5a6e9d1d39e954f047179 100644 (file)
--- a/liblttng-ust-libc-wrapper/lttng-ust-malloc.c
+++ b/liblttng-ust-libc-wrapper/lttng-ust-malloc.c
@@ -18,6 +18,11 @@
  */
 
 #define _GNU_SOURCE
+/*
+ * Do _not_ define _LGPL_SOURCE because we don't want to create a
+ * circular dependency loop between this malloc wrapper, liburcu and
+ * libc.
+ */
 #include <lttng/ust-dlfcn.h>
 #include <sys/types.h>
 #include <stdio.h>
@@ -25,13 +30,13 @@
 #include <urcu/system.h>
 #include <urcu/uatomic.h>
 #include <urcu/compiler.h>
-#include <urcu/tls-compat.h>
 #include <urcu/arch.h>
 #include <lttng/align.h>
+#include <helper.h>
 
 #define TRACEPOINT_DEFINE
 #define TRACEPOINT_CREATE_PROBES
-#define TP_IP_PARAM caller
+#define TP_IP_PARAM ip
 #include "ust_libc.h"
 
 #define STATIC_CALLOC_LEN 4096
@@ -86,13 +91,13 @@ void ust_malloc_spin_unlock(pthread_mutex_t *lock)
        uatomic_set(&ust_malloc_lock, 0);
 }
 
-#define calloc static_calloc
-#define pthread_mutex_lock ust_malloc_spin_lock
-#define pthread_mutex_unlock ust_malloc_spin_unlock
-static DEFINE_URCU_TLS(int, malloc_nesting);
-#undef ust_malloc_spin_unlock
-#undef ust_malloc_spin_lock
-#undef calloc
+/*
+ * Use initial-exec TLS model for the malloc_nesting nesting guard
+ * variable to ensure that the glibc implementation of the TLS access
+ * don't trigger infinite recursion by calling the memory allocator
+ * wrapper functions, which could happen with global-dynamic.
+ */
+static __thread __attribute__((tls_model("initial-exec"))) int malloc_nesting;
 
 /*
  * Static allocator to use when initially executing dlsym(). It keeps a
@@ -251,7 +256,7 @@ void *malloc(size_t size)
 {
        void *retval;
 
-       URCU_TLS(malloc_nesting)++;
+       malloc_nesting++;
        if (cur_alloc.malloc == NULL) {
                lookup_all_symbols();
                if (cur_alloc.malloc == NULL) {
@@ -260,17 +265,17 @@ void *malloc(size_t size)
                }
        }
        retval = cur_alloc.malloc(size);
-       if (URCU_TLS(malloc_nesting) == 1) {
+       if (malloc_nesting == 1) {
                tracepoint(lttng_ust_libc, malloc,
-                       size, retval, __builtin_return_address(0));
+                       size, retval, LTTNG_UST_CALLER_IP());
        }
-       URCU_TLS(malloc_nesting)--;
+       malloc_nesting--;
        return retval;
 }
 
 void free(void *ptr)
 {
-       URCU_TLS(malloc_nesting)++;
+       malloc_nesting++;
        /*
         * Check whether the memory was allocated with
         * static_calloc_align, in which case there is nothing to free.
@@ -280,9 +285,9 @@ void free(void *ptr)
                goto end;
        }
 
-       if (URCU_TLS(malloc_nesting) == 1) {
+       if (malloc_nesting == 1) {
                tracepoint(lttng_ust_libc, free,
-                       ptr, __builtin_return_address(0));
+                       ptr, LTTNG_UST_CALLER_IP());
        }
 
        if (cur_alloc.free == NULL) {
@@ -294,14 +299,14 @@ void free(void *ptr)
        }
        cur_alloc.free(ptr);
 end:
-       URCU_TLS(malloc_nesting)--;
+       malloc_nesting--;
 }
 
 void *calloc(size_t nmemb, size_t size)
 {
        void *retval;
 
-       URCU_TLS(malloc_nesting)++;
+       malloc_nesting++;
        if (cur_alloc.calloc == NULL) {
                lookup_all_symbols();
                if (cur_alloc.calloc == NULL) {
@@ -310,11 +315,11 @@ void *calloc(size_t nmemb, size_t size)
                }
        }
        retval = cur_alloc.calloc(nmemb, size);
-       if (URCU_TLS(malloc_nesting) == 1) {
+       if (malloc_nesting == 1) {
                tracepoint(lttng_ust_libc, calloc,
-                       nmemb, size, retval, __builtin_return_address(0));
+                       nmemb, size, retval, LTTNG_UST_CALLER_IP());
        }
-       URCU_TLS(malloc_nesting)--;
+       malloc_nesting--;
        return retval;
 }
 
@@ -322,7 +327,7 @@ void *realloc(void *ptr, size_t size)
 {
        void *retval;
 
-       URCU_TLS(malloc_nesting)++;
+       malloc_nesting++;
        /*
         * Check whether the memory was allocated with
         * static_calloc_align, in which case there is nothing
@@ -363,11 +368,11 @@ void *realloc(void *ptr, size_t size)
        }
        retval = cur_alloc.realloc(ptr, size);
 end:
-       if (URCU_TLS(malloc_nesting) == 1) {
+       if (malloc_nesting == 1) {
                tracepoint(lttng_ust_libc, realloc,
-                       ptr, size, retval, __builtin_return_address(0));
+                       ptr, size, retval, LTTNG_UST_CALLER_IP());
        }
-       URCU_TLS(malloc_nesting)--;
+       malloc_nesting--;
        return retval;
 }
 
@@ -375,7 +380,7 @@ void *memalign(size_t alignment, size_t size)
 {
        void *retval;
 
-       URCU_TLS(malloc_nesting)++;
+       malloc_nesting++;
        if (cur_alloc.memalign == NULL) {
                lookup_all_symbols();
                if (cur_alloc.memalign == NULL) {
@@ -384,12 +389,12 @@ void *memalign(size_t alignment, size_t size)
                }
        }
        retval = cur_alloc.memalign(alignment, size);
-       if (URCU_TLS(malloc_nesting) == 1) {
+       if (malloc_nesting == 1) {
                tracepoint(lttng_ust_libc, memalign,
                        alignment, size, retval,
-                       __builtin_return_address(0));
+                       LTTNG_UST_CALLER_IP());
        }
-       URCU_TLS(malloc_nesting)--;
+       malloc_nesting--;
        return retval;
 }
 
@@ -397,7 +402,7 @@ int posix_memalign(void **memptr, size_t alignment, size_t size)
 {
        int retval;
 
-       URCU_TLS(malloc_nesting)++;
+       malloc_nesting++;
        if (cur_alloc.posix_memalign == NULL) {
                lookup_all_symbols();
                if (cur_alloc.posix_memalign == NULL) {
@@ -406,12 +411,12 @@ int posix_memalign(void **memptr, size_t alignment, size_t size)
                }
        }
        retval = cur_alloc.posix_memalign(memptr, alignment, size);
-       if (URCU_TLS(malloc_nesting) == 1) {
+       if (malloc_nesting == 1) {
                tracepoint(lttng_ust_libc, posix_memalign,
                        *memptr, alignment, size,
-                       retval, __builtin_return_address(0));
+                       retval, LTTNG_UST_CALLER_IP());
        }
-       URCU_TLS(malloc_nesting)--;
+       malloc_nesting--;
        return retval;
 }