From dd654bf9ba1848bf9ed250f8ebaa5097c383dcf8 Mon Sep 17 00:00:00 2001 From: Allan McRae Date: Wed, 5 Feb 2014 21:19:51 +1000 Subject: Revert "Patch 2/4 of the effort to make TLS access async-signal-safe." This reverts commit 1f33d36a8a9e78c81bed59b47f260723f56bb7e6. Conflicts: elf/dl-misc.c Also reverts the follow commits that were bug fixes to new code introduced in the above commit: 063b2acbce83549df82ab30f5af573f1b9c4bd19 b627fdd58554bc36bd344dc40a8787c4b7a9cc46 e81c64bba13d2d8b2a4e53254a82cc80f27c8497 --- elf/dl-misc.c | 142 ---------------------------------------------------------- elf/dl-tls.c | 34 +++++++------- 2 files changed, 16 insertions(+), 160 deletions(-) (limited to 'elf') diff --git a/elf/dl-misc.c b/elf/dl-misc.c index 043185a..8fd6710 100644 --- a/elf/dl-misc.c +++ b/elf/dl-misc.c @@ -19,7 +19,6 @@ #include #include #include -#include #include #include #include @@ -365,144 +364,3 @@ _dl_higher_prime_number (unsigned long int n) return *low; } - -/* To support accessing TLS variables from signal handlers, we need an - async signal safe memory allocator. These routines are never - themselves invoked reentrantly (all calls to them are surrounded by - signal masks) but may be invoked concurrently from many threads. - The current implementation is not particularly performant nor space - efficient, but it will be used rarely (and only in binaries that use - dlopen.) The API matches that of malloc() and friends. */ - -struct __signal_safe_allocator_header -{ - size_t size; - void *start; -}; - -static inline struct __signal_safe_allocator_header * -ptr_to_signal_safe_allocator_header (void *ptr) -{ - return (struct __signal_safe_allocator_header *) - ((char *) (ptr) - sizeof (struct __signal_safe_allocator_header)); -} - -void *weak_function -__signal_safe_memalign (size_t boundary, size_t size) -{ - struct __signal_safe_allocator_header *header; - - if (boundary < sizeof (*header)) - boundary = sizeof (*header); - - /* Boundary must be a power of two. */ - if (!powerof2 (boundary)) - return NULL; - - size_t pg = GLRO (dl_pagesize); - size_t padded_size; - if (boundary <= pg) - { - /* We'll get a pointer certainly aligned to boundary, so just - add one more boundary-sized chunk to hold the header. */ - padded_size = roundup (size, boundary) + boundary; - } - else - { - /* If we want K pages aligned to a J-page boundary, K+J+1 pages - contains at least one such region that isn't directly at the start - (so we can place the header.) This is wasteful, but you're the one - who wanted 64K-aligned TLS. */ - padded_size = roundup (size, pg) + boundary + pg; - } - - - size_t actual_size = roundup (padded_size, pg); - void *actual = mmap (NULL, actual_size, PROT_READ | PROT_WRITE, - MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); - if (actual == MAP_FAILED) - return NULL; - - if (boundary <= pg) - { - header = actual + boundary - sizeof (*header); - } - else - { - intptr_t actual_pg = ((intptr_t) actual) / pg; - intptr_t boundary_pg = boundary / pg; - intptr_t start_pg = actual_pg + boundary_pg; - start_pg -= start_pg % boundary_pg; - if (start_pg > (actual_pg + 1)) - { - int ret = munmap (actual, (start_pg - actual_pg - 1) * pg); - assert (ret == 0); - actual = (void *) ((start_pg - 1) * pg); - } - char *start = (void *) (start_pg * pg); - header = ptr_to_signal_safe_allocator_header (start); - } - - header->size = actual_size; - header->start = actual; - void *ptr = header; - ptr += sizeof (*header); - if (((intptr_t) ptr) % boundary != 0) - _dl_fatal_printf ("__signal_safe_memalign produced incorrect alignment\n"); - return ptr; -} - -void * weak_function -__signal_safe_malloc (size_t size) -{ - return __signal_safe_memalign (1, size); -} - -void weak_function -__signal_safe_free (void *ptr) -{ - if (ptr == NULL) - return; - - struct __signal_safe_allocator_header *header - = ptr_to_signal_safe_allocator_header (ptr); - int ret = munmap (header->start, header->size); - - assert (ret == 0); -} - -void * weak_function -__signal_safe_realloc (void *ptr, size_t size) -{ - if (size == 0) - { - __signal_safe_free (ptr); - return NULL; - } - if (ptr == NULL) - return __signal_safe_malloc (size); - - struct __signal_safe_allocator_header *header - = ptr_to_signal_safe_allocator_header (ptr); - size_t old_size = header->size; - if (old_size - sizeof (*header) >= size) - return ptr; - - void *new_ptr = __signal_safe_malloc (size); - if (new_ptr == NULL) - return NULL; - - memcpy (new_ptr, ptr, old_size); - __signal_safe_free (ptr); - - return new_ptr; -} - -void * weak_function -__signal_safe_calloc (size_t nmemb, size_t size) -{ - void *ptr = __signal_safe_malloc (nmemb * size); - if (ptr == NULL) - return NULL; - return memset (ptr, 0, nmemb * size); -} diff --git a/elf/dl-tls.c b/elf/dl-tls.c index c1802e7..28e4fbe 100644 --- a/elf/dl-tls.c +++ b/elf/dl-tls.c @@ -293,7 +293,7 @@ allocate_dtv (void *result) initial set of modules. This should avoid in most cases expansions of the dtv. */ dtv_length = GL(dl_tls_max_dtv_idx) + DTV_SURPLUS; - dtv = __signal_safe_calloc (dtv_length + 2, sizeof (dtv_t)); + dtv = calloc (dtv_length + 2, sizeof (dtv_t)); if (dtv != NULL) { /* This is the initial length of the dtv. */ @@ -470,7 +470,7 @@ _dl_clear_dtv (dtv_t *dtv) for (size_t cnt = 0; cnt < dtv[-1].counter; ++cnt) if (! dtv[1 + cnt].pointer.is_static && dtv[1 + cnt].pointer.val != TLS_DTV_UNALLOCATED) - __signal_safe_free (dtv[1 + cnt].pointer.val); + free (dtv[1 + cnt].pointer.val); memset (dtv, '\0', (dtv[-1].counter + 1) * sizeof (dtv_t)); } @@ -491,11 +491,11 @@ _dl_deallocate_tls (void *tcb, bool dealloc_tcb) for (size_t cnt = 0; cnt < dtv[-1].counter; ++cnt) if (! dtv[1 + cnt].pointer.is_static && dtv[1 + cnt].pointer.val != TLS_DTV_UNALLOCATED) - __signal_safe_free (dtv[1 + cnt].pointer.val); + free (dtv[1 + cnt].pointer.val); /* The array starts with dtv[-1]. */ if (dtv != GL(dl_initial_dtv)) - __signal_safe_free (dtv - 1); + free (dtv - 1); if (dealloc_tcb) { @@ -537,7 +537,8 @@ static void * allocate_and_init (struct link_map *map) { void *newp; - newp = __signal_safe_memalign (map->l_tls_align, map->l_tls_blocksize); + + newp = __libc_memalign (map->l_tls_align, map->l_tls_blocksize); if (newp == NULL) oom (); @@ -607,27 +608,25 @@ _dl_update_slotinfo (unsigned long int req_modid) if (gen <= dtv[0].counter) continue; - size_t modid = total + cnt; - /* If there is no map this means the entry is empty. */ struct link_map *map = listp->slotinfo[cnt].map; if (map == NULL) { /* If this modid was used at some point the memory might still be allocated. */ - if (dtv[-1].counter >= modid - && !dtv[modid].pointer.is_static - && dtv[modid].pointer.val != TLS_DTV_UNALLOCATED) + if (! dtv[total + cnt].pointer.is_static + && dtv[total + cnt].pointer.val != TLS_DTV_UNALLOCATED) { - __signal_safe_free (dtv[modid].pointer.val); - dtv[modid].pointer.val = TLS_DTV_UNALLOCATED; + free (dtv[total + cnt].pointer.val); + dtv[total + cnt].pointer.val = TLS_DTV_UNALLOCATED; } continue; } - assert (modid == map->l_tls_modid); /* Check whether the current dtv array is large enough. */ + size_t modid = map->l_tls_modid; + assert (total + cnt == modid); if (dtv[-1].counter < modid) { /* Reallocate the dtv. */ @@ -641,18 +640,17 @@ _dl_update_slotinfo (unsigned long int req_modid) { /* This is the initial dtv that was allocated during rtld startup using the dl-minimal.c - malloc instead of the real allocator. We can't + malloc instead of the real malloc. We can't free it, we have to abandon the old storage. */ - newp = __signal_safe_malloc ( - (2 + newsize) * sizeof (dtv_t)); + newp = malloc ((2 + newsize) * sizeof (dtv_t)); if (newp == NULL) oom (); memcpy (newp, &dtv[-1], (2 + oldsize) * sizeof (dtv_t)); } else { - newp = __signal_safe_realloc (&dtv[-1], + newp = realloc (&dtv[-1], (2 + newsize) * sizeof (dtv_t)); if (newp == NULL) oom (); @@ -682,7 +680,7 @@ _dl_update_slotinfo (unsigned long int req_modid) deallocate even if it is this dtv entry we are supposed to load. The reason is that we call memalign and not malloc. */ - __signal_safe_free (dtv[modid].pointer.val); + free (dtv[modid].pointer.val); /* This module is loaded dynamically- We defer memory allocation. */ -- cgit v1.1