From fde89ad0091e492bd2d99d9d4925fbd62a7dc643 Mon Sep 17 00:00:00 2001 From: Roland McGrath Date: Fri, 6 Dec 2002 11:15:07 +0000 Subject: * sysdeps/generic/libc-tls.c (__libc_setup_tls): Cope with zero ALIGN. * malloc/hooks.c [_LIBC && (USE___THREAD || (USE_TLS && !SHARED))] (malloc_starter, memalign_starter, free_starter): Don't define these. * malloc/malloc.c [_LIBC && (USE___THREAD || (USE_TLS && !SHARED))]: Don't declare them either. * malloc/arena.c (ptmalloc_init) [_LIBC && USE_TLS]: Don't call __pthread_initialize, so no need to set hooks to *_starter. (ptmalloc_init_minimal): New function, broken out of ptmalloc_init. [_LIBC && SHARED && USE_TLS && !USE___THREAD] (__libc_malloc_pthread_startup): New function. * malloc/Versions (libc: GLIBC_PRIVATE): New set, add that function. * malloc/hooks.c (memalign_starter): New function. * malloc/malloc.c: Declare it. * malloc/arena.c (save_memalign_hook): New variable. (ptmalloc_init): Set __memalign_hook to memalign_starter. * elf/dl-minimal.c (free): Clear the memory. (calloc): Just call malloc, knowing all memory it returns is cleared. * sysdeps/generic/dl-tls.c (allocate_dtv): Use calloc instead of malloc and memset; calloc can avoid the zeroing when redundant. (_dl_tls_setup): Likewise. * elf/dl-load.c (decompose_rpath): Likewise. * sysdeps/generic/libc-tls.c (__libc_setup_tls): Comment out memset call, since memory from sbrk at startup is already zero. * elf/rtld.c (_dl_start, dl_main): TLS_INIT_TP macro now returns an error string for failure, null for success. Update callers. * sysdeps/generic/libc-tls.c (__libc_setup_tls): Likewise. * elf/dl-load.c (_dl_map_object_from_fd): Likewise. --- linuxthreads/ChangeLog | 18 ++++++++++++++ linuxthreads/pthread.c | 49 ++++++++++++++++++++++++++++++++++++++- linuxthreads/sysdeps/alpha/tls.h | 1 + linuxthreads/sysdeps/i386/tls.h | 47 ++++++++++++++++++------------------- linuxthreads/sysdeps/x86_64/tls.h | 3 ++- 5 files changed, 92 insertions(+), 26 deletions(-) (limited to 'linuxthreads') diff --git a/linuxthreads/ChangeLog b/linuxthreads/ChangeLog index f47f3192b8..1fa6aea5c7 100644 --- a/linuxthreads/ChangeLog +++ b/linuxthreads/ChangeLog @@ -1,3 +1,21 @@ +2002-12-05 Roland McGrath + + * pthread.c (__pthread_initialize_minimal) + [USE_TLS && SHARED && !USE___THREAD]: Initialize TLS and set up the + TCB if the dynamic linker didn't do it at startup. + + * sysdeps/i386/tls.h (TLS_INIT_TP): Make it return zero or an error + string. + (TLS_DO_SET_THREAD_AREA, TLS_DO_MODIFY_LDT, TLS_SETUP_GS_SEGMENT): + Submacros updated. + * sysdeps/x86_64/tls.h (TLS_INIT_TP): Likewise. + * sysdeps/alpha/tls.h (TLS_INIT_TP): Likewise (always zero). + +2002-12-03 Roland McGrath + + * pthread.c (pthread_initialize) [SHARED]: Copy dl_error_tsd value + from dynamic linker internal cell to new libc cell. + 2002-11-28 Roland McGrath * tst-context.c: #define IS_IN_libpthread around #include diff --git a/linuxthreads/pthread.c b/linuxthreads/pthread.c index f119619602..8216985972 100644 --- a/linuxthreads/pthread.c +++ b/linuxthreads/pthread.c @@ -317,6 +317,49 @@ __pthread_initialize_minimal(void) /* Unlike in the dynamically linked case the dynamic linker has not taken care of initializing the TLS data structures. */ __libc_setup_tls (TLS_TCB_SIZE, TLS_TCB_ALIGN); +# elif !USE___THREAD + if (__builtin_expect (GL(dl_tls_max_dtv_idx) == 0, 0)) + { + /* There is no actual TLS being used, so the thread register + was not initialized in the dynamic linker. */ + + /* We need to install special hooks so that the malloc and memalign + calls in _dl_tls_setup and _dl_allocate_tls won't cause full + malloc initialization that will try to set up its thread state. */ + + extern void __libc_malloc_pthread_startup (bool first_time); + __libc_malloc_pthread_startup (true); + + if (__builtin_expect (_dl_tls_setup (), 0) + || __builtin_expect ((self = _dl_allocate_tls (NULL)) == NULL, 0)) + { + static const char msg[] = "\ +cannot allocate TLS data structures for initial thread\n"; + TEMP_FAILURE_RETRY (__libc_write (STDERR_FILENO, + msg, sizeof msg - 1)); + abort (); + } + const char *lossage = TLS_INIT_TP (self, 0); + if (__builtin_expect (lossage != NULL, 0)) + { + static const char msg[] = "cannot set up thread-local storage: "; + const char nl = '\n'; + TEMP_FAILURE_RETRY (__libc_write (STDERR_FILENO, + msg, sizeof msg - 1)); + TEMP_FAILURE_RETRY (__libc_write (STDERR_FILENO, + lossage, strlen (lossage))); + TEMP_FAILURE_RETRY (__libc_write (STDERR_FILENO, &nl, 1)); + } + + /* Though it was allocated with libc's malloc, that was done without + the user's __malloc_hook installed. A later realloc that uses + the hooks might not work with that block from the plain malloc. + So we record this block as unfreeable just as the dynamic linker + does when it allocates the DTV before the libc malloc exists. */ + GL(dl_initial_dtv) = GET_DTV (self); + + __libc_malloc_pthread_startup (false); + } # endif self = THREAD_SELF; @@ -344,7 +387,9 @@ __pthread_initialize_minimal(void) /* And fill in the pointer the the thread __pthread_handles array. */ __pthread_handles[0].h_descr = self; -#else + +#else /* USE_TLS */ + /* First of all init __pthread_handles[0] and [1]. */ # if __LT_SPINLOCK_INIT != 0 __pthread_handles[0].h_lock = __LOCK_INITIALIZER; @@ -513,6 +558,8 @@ static void pthread_initialize(void) __pthread_smp_kernel = is_smp_system (); #ifdef SHARED + /* Transfer the old value from the dynamic linker's internal location. */ + *__libc_dl_error_tsd () = *(*GL(dl_error_catch_tsd)) (); GL(dl_error_catch_tsd) = &__libc_dl_error_tsd; #endif } diff --git a/linuxthreads/sysdeps/alpha/tls.h b/linuxthreads/sysdeps/alpha/tls.h index c5cdc0a5b0..98d0d9f93e 100644 --- a/linuxthreads/sysdeps/alpha/tls.h +++ b/linuxthreads/sysdeps/alpha/tls.h @@ -92,6 +92,7 @@ typedef struct register tcbhead_t *__self = (void *)(descr); \ __self->tcb = __self; \ __builtin_set_thread_pointer(__self); \ + 0; \ }) /* Return the address of the dtv for the current thread. */ diff --git a/linuxthreads/sysdeps/i386/tls.h b/linuxthreads/sysdeps/i386/tls.h index 8bbe5f28e6..c244801bf4 100644 --- a/linuxthreads/sysdeps/i386/tls.h +++ b/linuxthreads/sysdeps/i386/tls.h @@ -106,20 +106,18 @@ typedef struct # endif # if __ASSUME_LDT_WORKS > 0 -# define TLS_DO_MODIFY_LDT_KERNEL_CHECK /* Nothing to do. */ +# define TLS_DO_MODIFY_LDT_KERNEL_CHECK(doit) (doit) /* Nothing to check. */ # else # include "useldt.h" /* For the structure. */ -# define TLS_DO_MODIFY_LDT_KERNEL_CHECK \ - if (__builtin_expect (GL(dl_osversion) < 131939, 0)) \ - _dl_fatal_printf ("kernel %u.%u.%u cannot support thread-local storage\n",\ - (GL(dl_osversion) >> 16) & 0xff, \ - (GL(dl_osversion) >> 8) & 0xff, \ - (GL(dl_osversion) >> 0) & 0xff); +# define TLS_DO_MODIFY_LDT_KERNEL_CHECK(doit) \ + (__builtin_expect (GL(dl_osversion) < 131939, 0) \ + ? "kernel too old for thread-local storage support" \ + : (doit)) # endif # define TLS_DO_MODIFY_LDT(descr, nr) \ +TLS_DO_MODIFY_LDT_KERNEL_CHECK( \ ({ \ - TLS_DO_MODIFY_LDT_KERNEL_CHECK \ struct modify_ldt_ldt_s ldt_entry = \ { nr, (unsigned long int) (descr), 0xfffff /* 4GB in pages */, \ 1, 0, 0, 1, 0, 1, 0 }; \ @@ -134,8 +132,10 @@ typedef struct here. */ \ "m" (ldt_entry), TLS_EBX_ARG (1), "c" (&ldt_entry), \ "d" (sizeof (ldt_entry))); \ - __builtin_expect (result, 0) != 0 ? -1 : nr * 8 + 7; \ -}) + __builtin_expect (result, 0) == 0 \ + ? ({ asm ("movw %w0, %%gs" : : "q" ((nr) * 8 + 7)); NULL; }) \ + : "cannot set up LDT for thread-local storage"; \ +})) # define TLS_DO_SET_THREAD_AREA(descr, secondcall) \ ({ \ @@ -156,41 +156,40 @@ typedef struct to let the compiler know that we are accessing LDT_ENTRY \ here. */ \ TLS_EBX_ARG (&ldt_entry), "m" (ldt_entry)); \ - __builtin_expect (result, 0) == 0 ? ldt_entry.entry_number * 8 + 3 : -1; \ + if (__builtin_expect (result, 0) == 0) \ + asm ("movw %w0, %%gs" : : "q" (ldt_entry.entry_number * 8 + 3)); \ + result; \ }) # ifdef __ASSUME_SET_THREAD_AREA_SYSCALL -# define TLS_SETUP_GS_SEGMENT(descr, secondcall) \ - TLS_DO_SET_THREAD_AREA (descr, firstcall) +# define TLS_SETUP_GS_SEGMENT(descr, secondcall) \ + (TLS_DO_SET_THREAD_AREA (descr, firstcall) \ + ? "set_thread_area failed when setting up thread-local storage" : NULL) # elif defined __NR_set_thread_area # define TLS_SETUP_GS_SEGMENT(descr, secondcall) \ - ({ int __seg = TLS_DO_SET_THREAD_AREA (descr, secondcall); \ - __seg == -1 ? TLS_DO_MODIFY_LDT (descr, 0) : __seg; }) + (TLS_DO_SET_THREAD_AREA (descr, secondcall) \ + ? TLS_DO_MODIFY_LDT (descr, 0) : NULL) # else # define TLS_SETUP_GS_SEGMENT(descr, secondcall) \ TLS_DO_MODIFY_LDT ((descr), 0) # endif + /* Code to initially initialize the thread pointer. This might need special attention since 'errno' is not yet available and if the - operation can cause a failure 'errno' must not be touched. */ + operation can cause a failure 'errno' must not be touched. + + The value of this macro is null if successful, or an error string. */ # define TLS_INIT_TP(descr, secondcall) \ ({ \ void *_descr = (descr); \ tcbhead_t *head = _descr; \ - int __gs; \ \ head->tcb = _descr; \ /* For now the thread descriptor is at the same address. */ \ head->self = _descr; \ \ - __gs = TLS_SETUP_GS_SEGMENT (_descr, secondcall); \ - if (__builtin_expect (__gs, 7) != -1) \ - { \ - asm ("movw %w0, %%gs" : : "q" (__gs)); \ - __gs = 0; \ - } \ - __gs; \ + TLS_SETUP_GS_SEGMENT (_descr, secondcall); \ }) diff --git a/linuxthreads/sysdeps/x86_64/tls.h b/linuxthreads/sysdeps/x86_64/tls.h index e886760690..a649898f3f 100644 --- a/linuxthreads/sysdeps/x86_64/tls.h +++ b/linuxthreads/sysdeps/x86_64/tls.h @@ -105,7 +105,8 @@ typedef struct "D" ((unsigned long int) ARCH_SET_FS), \ "S" (_descr) \ : "memory", "cc", "r11", "cx"); \ - _result ? -1 : 0; \ + \ + _result ? "cannot set %fs base address for thread-local storage" : 0; \ }) /* Return the address of the dtv for the current thread. */ -- cgit v1.2.3