* 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.

19 files changed, 296 insertions, 68 deletions

diff --git a/ChangeLog b/ChangeLog
index 845c7c4e2c..0bf1edabf9 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,38 @@
+2002-12-06  Roland McGrath  <roland@redhat.com>
+
+	* 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.
+
 2002-12-05  Jakub Jelinek  <jakub@redhat.com>
 
 	* sysdeps/unix/sysv/linux/x86_64/syscalls.list (sendfile): Change
diff --git a/elf/dl-load.c b/elf/dl-load.c
index d80f30813f..9d9ba94539 100644
--- a/elf/dl-load.c
+++ b/elf/dl-load.c
@@ -513,8 +513,7 @@ decompose_rpath (struct r_search_path_struct *sps,
 	    {
 	      /* This object is on the list of objects for which the
 		 RUNPATH and RPATH must not be used.  */
-	      result = (struct r_search_path_elem **)
-		malloc (sizeof (*result));
+	      result = calloc (1, sizeof *result);
 	      if (result == NULL)
 		{
 		signal_error_cache:
@@ -523,8 +522,6 @@ decompose_rpath (struct r_search_path_struct *sps,
 		  INTUSE(_dl_signal_error) (ENOMEM, NULL, NULL, errstring);
 		}
 
-	      result[0] = NULL;
-
 	      sps->dirs = result;
 	      sps->malloced = 1;
 
@@ -994,7 +991,8 @@ cannot allocate TLS data structures for initial thread");
 		}
 
 	      /* Now we install the TCB in the thread register.  */
-	      if (__builtin_expect (TLS_INIT_TP (tcb, 0), 0) != -1)
+	      errstring = TLS_INIT_TP (tcb, 0);
+	      if (__builtin_expect (errstring == NULL, 1))
 		{
 		  /* Now we are all good.  */
 		  l->l_tls_modid = ++GL(dl_tls_max_dtv_idx);
@@ -1002,7 +1000,9 @@ cannot allocate TLS data structures for initial thread");
 		}
 
 	      /* The kernel is too old or somesuch.  */
+	      errval = 0;
 	      _dl_deallocate_tls (tcb, 1);
+	      goto call_lose;
 	    }
 #endif
 
diff --git a/elf/dl-minimal.c b/elf/dl-minimal.c
index d1619cfb0c..3a51df30fb 100644
--- a/elf/dl-minimal.c
+++ b/elf/dl-minimal.c
@@ -104,9 +104,10 @@ malloc (size_t n)
 void * weak_function
 calloc (size_t nmemb, size_t size)
 {
-  size_t total = nmemb * size;
-  void *result = malloc (total);
-  return memset (result, '\0', total);
+  /* New memory from the trivial malloc above is always already cleared.
+     (We make sure that's true in the rare occasion it might not be,
+     by clearing memory in free, below.)  */
+  return malloc (nmemb * size);
 }
 
 /* This will rarely be called.  */
@@ -115,7 +116,12 @@ free (void *ptr)
 {
   /* We can free only the last block allocated.  */
   if (ptr == alloc_last_block)
-    alloc_ptr = alloc_last_block;
+    {
+      /* Since this is rare, we clear the freed block here
+	 so that calloc can presume malloc returns cleared memory.  */
+      memset (alloc_last_block, '\0', alloc_ptr - alloc_last_block);
+      alloc_ptr = alloc_last_block;
+    }
 }
 
 /* This is only called with the most recent block returned by malloc.  */
diff --git a/elf/rtld.c b/elf/rtld.c
index f1886431b8..e43a0e998d 100644
--- a/elf/rtld.c
+++ b/elf/rtld.c
@@ -404,16 +404,17 @@ _dl_start (void *arg)
 	INSTALL_DTV ((char *) tlsblock + bootstrap_map.l_tls_offset,
 		     initdtv);
 
-	if (TLS_INIT_TP ((char *) tlsblock + bootstrap_map.l_tls_offset, 0)
-	    != 0)
-	  _dl_fatal_printf ("cannot setup thread-local storage\n");
+	const char *lossage = TLS_INIT_TP ((char *) tlsblock
+					   + bootstrap_map.l_tls_offset, 0);
 # elif TLS_DTV_AT_TP
 	INSTALL_DTV (tlsblock, initdtv);
-	if (TLS_INIT_TP (tlsblock, 0) != 0)
-	  _dl_fatal_printf ("cannot setup thread-local storage\n");
+	const char *lossage = TLS_INIT_TP (tlsblock, 0);
 # else
 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 # endif
+	if (__builtin_expect (lossage != NULL, 0))
+	  _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
+			    lossage);
 
 	/* So far this is module number one.  */
 	bootstrap_map.l_tls_modid = 1;
@@ -1564,7 +1565,9 @@ cannot allocate TLS data structures for initial thread");
 
       /* And finally install it for the main thread.  If ld.so itself uses
 	 TLS we know the thread pointer was initialized earlier.  */
-      TLS_INIT_TP (tcbp, USE___THREAD);
+      const char *lossage = TLS_INIT_TP (tcbp, USE___THREAD);
+      if (__builtin_expect (lossage != NULL, 0))
+	_dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage);
     }
 #endif
 
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  <roland@redhat.com>
+
+	* 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  <roland@redhat.com>
+
+	* pthread.c (pthread_initialize) [SHARED]: Copy dl_error_tsd value
+	from dynamic linker internal cell to new libc cell.
+
 2002-11-28  Roland McGrath  <roland@redhat.com>
 
 	* tst-context.c: #define IS_IN_libpthread around #include <tls.h>
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.  */
diff --git a/malloc/arena.c b/malloc/arena.c
index 090e3c1dd6..27d2d9e058 100644
--- a/malloc/arena.c
+++ b/malloc/arena.c
@@ -136,6 +136,11 @@ int __malloc_initialized = -1;
 
 static __malloc_ptr_t (*save_malloc_hook) __MALLOC_P ((size_t __size,
 						       __const __malloc_ptr_t));
+# if !defined _LIBC || !defined USE_TLS || (defined SHARED && !USE___THREAD)
+static __malloc_ptr_t (*save_memalign_hook) __MALLOC_P ((size_t __align,
+							 size_t __size,
+						       __const __malloc_ptr_t));
+# endif
 static void           (*save_free_hook) __MALLOC_P ((__malloc_ptr_t __ptr,
 						     __const __malloc_ptr_t));
 static Void_t*        save_arena;
@@ -322,6 +327,51 @@ next_env_entry (char ***position)
 }
 #endif /* _LIBC */
 
+/* Set up basic state so that _int_malloc et al can work.  */
+static void
+ptmalloc_init_minimal __MALLOC_P((void))
+{
+#if DEFAULT_TOP_PAD != 0
+  mp_.top_pad        = DEFAULT_TOP_PAD;
+#endif
+  mp_.n_mmaps_max    = DEFAULT_MMAP_MAX;
+  mp_.mmap_threshold = DEFAULT_MMAP_THRESHOLD;
+  mp_.trim_threshold = DEFAULT_TRIM_THRESHOLD;
+  mp_.pagesize       = malloc_getpagesize;
+}
+
+#ifdef _LIBC
+# if defined SHARED && defined USE_TLS && !USE___THREAD
+# include <stdbool.h>
+
+/* This is called by __pthread_initialize_minimal when it needs to use
+   malloc to set up the TLS state.  We cannot do the full work of
+   ptmalloc_init (below) until __pthread_initialize_minimal has finished,
+   so it has to switch to using the special startup-time hooks while doing
+   those allocations.  */
+void
+__libc_malloc_pthread_startup (bool first_time)
+{
+  if (first_time)
+    {
+      ptmalloc_init_minimal ();
+      save_malloc_hook = __malloc_hook;
+      save_memalign_hook = __memalign_hook;
+      save_free_hook = __free_hook;
+      __malloc_hook = malloc_starter;
+      __memalign_hook = memalign_starter;
+      __free_hook = free_starter;
+    }
+  else
+    {
+      __malloc_hook = save_malloc_hook;
+      __memalign_hook = save_memalign_hook;
+      __free_hook = save_free_hook;
+    }
+}
+# endif
+#endif
+
 static void
 ptmalloc_init __MALLOC_P((void))
 {
@@ -335,25 +385,37 @@ ptmalloc_init __MALLOC_P((void))
   if(__malloc_initialized >= 0) return;
   __malloc_initialized = 0;
 
-  mp_.top_pad        = DEFAULT_TOP_PAD;
-  mp_.n_mmaps_max    = DEFAULT_MMAP_MAX;
-  mp_.mmap_threshold = DEFAULT_MMAP_THRESHOLD;
-  mp_.trim_threshold = DEFAULT_TRIM_THRESHOLD;
-  mp_.pagesize       = malloc_getpagesize;
+#ifdef _LIBC
+# if defined SHARED && defined USE_TLS && !USE___THREAD
+  /* ptmalloc_init_minimal may already have been called via
+     __libc_malloc_pthread_startup, above.  */
+  if (mp_.pagesize == 0)
+# endif
+#endif
+    ptmalloc_init_minimal();
 
 #ifndef NO_THREADS
+# if defined _LIBC && defined USE_TLS
+  /* We know __pthread_initialize_minimal has already been called,
+     and that is enough.  */
+#   define NO_STARTER
+# endif
+# ifndef NO_STARTER
   /* With some threads implementations, creating thread-specific data
      or initializing a mutex may call malloc() itself.  Provide a
      simple starter version (realloc() won't work). */
   save_malloc_hook = __malloc_hook;
+  save_memalign_hook = __memalign_hook;
   save_free_hook = __free_hook;
   __malloc_hook = malloc_starter;
+  __memalign_hook = memalign_starter;
   __free_hook = free_starter;
-#ifdef _LIBC
+#  ifdef _LIBC
   /* Initialize the pthreads interface. */
   if (__pthread_initialize != NULL)
     __pthread_initialize();
-#endif
+#  endif /* !defined _LIBC */
+# endif	/* !defined NO_STARTER */
 #endif /* !defined NO_THREADS */
   mutex_init(&main_arena.mutex);
   main_arena.next = &main_arena;
@@ -363,8 +425,13 @@ ptmalloc_init __MALLOC_P((void))
   tsd_setspecific(arena_key, (Void_t *)&main_arena);
   thread_atfork(ptmalloc_lock_all, ptmalloc_unlock_all, ptmalloc_unlock_all2);
 #ifndef NO_THREADS
+# ifndef NO_STARTER
   __malloc_hook = save_malloc_hook;
+  __memalign_hook = save_memalign_hook;
   __free_hook = save_free_hook;
+# else
+#  undef NO_STARTER
+# endif
 #endif
 #ifdef _LIBC
   secure = __libc_enable_secure;
diff --git a/malloc/hooks.c b/malloc/hooks.c
index 7643e36714..0bd3e2a9ca 100644
--- a/malloc/hooks.c
+++ b/malloc/hooks.c
@@ -395,6 +395,17 @@ memalign_check(alignment, bytes, caller)
 
 #ifndef NO_THREADS
 
+# ifdef _LIBC
+#  if USE___THREAD || (defined USE_TLS && !defined SHARED)
+    /* These routines are never needed in this configuration.  */
+#   define NO_STARTER
+#  endif
+# endif
+
+# ifdef NO_STARTER
+#  undef NO_STARTER
+# else
+
 /* The following hooks are used when the global initialization in
    ptmalloc_init() hasn't completed yet. */
 
@@ -412,6 +423,20 @@ malloc_starter(sz, caller) size_t sz; const Void_t *caller;
   return victim ? BOUNDED_N(victim, sz) : 0;
 }
 
+static Void_t*
+#if __STD_C
+memalign_starter(size_t align, size_t sz, const Void_t *caller)
+#else
+memalign_starter(align, sz, caller) size_t align, sz; const Void_t *caller;
+#endif
+{
+  Void_t* victim;
+
+  victim = _int_memalign(&main_arena, align, sz);
+
+  return victim ? BOUNDED_N(victim, sz) : 0;
+}
+
 static void
 #if __STD_C
 free_starter(Void_t* mem, const Void_t *caller)
@@ -432,6 +457,7 @@ free_starter(mem, caller) Void_t* mem; const Void_t *caller;
   _int_free(&main_arena, mem);
 }
 
+# endif	/* !defiend NO_STARTER */
 #endif /* NO_THREADS */
 
 
diff --git a/malloc/malloc.c b/malloc/malloc.c
index 757e65a37f..36a244dad7 100644
--- a/malloc/malloc.c
+++ b/malloc/malloc.c
@@ -1498,8 +1498,19 @@ static Void_t*   realloc_check(Void_t* oldmem, size_t bytes,
 static Void_t*   memalign_check(size_t alignment, size_t bytes,
 				const Void_t *caller);
 #ifndef NO_THREADS
+# ifdef _LIBC
+#  if USE___THREAD || (defined USE_TLS && !defined SHARED)
+    /* These routines are never needed in this configuration.  */
+#   define NO_STARTER
+#  endif
+# endif
+# ifdef NO_STARTER
+#  undef NO_STARTER
+# else
 static Void_t*   malloc_starter(size_t sz, const Void_t *caller);
+static Void_t*   memalign_starter(size_t aln, size_t sz, const Void_t *caller);
 static void      free_starter(Void_t* mem, const Void_t *caller);
+# endif
 static Void_t*   malloc_atfork(size_t sz, const Void_t *caller);
 static void      free_atfork(Void_t* mem, const Void_t *caller);
 #endif
diff --git a/nptl/ChangeLog b/nptl/ChangeLog
index b6584d36a0..9d40cca747 100644
--- a/nptl/ChangeLog
+++ b/nptl/ChangeLog
@@ -1,5 +1,14 @@
+2002-12-06  Roland McGrath  <roland@redhat.com>
+
+	* allocatestack.c (__stack_user): Use uninitialized defn.
+	* init.c (__pthread_initialize_minimal): Initialize it here.
+
 2002-12-05  Roland McGrath  <roland@redhat.com>
 
+	* sysdeps/i386/tls.h (TLS_INIT_TP): Make it return zero or an error
+	string.
+	* sysdeps/x86_64/tls.h (TLS_INIT_TP): Likewise.
+
 	* sysdeps/unix/sysv/linux/i386/createthread.c (create_thread): Add
 	missing & here too.
 
diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c
index 00ce920f8a..3e057e9c7b 100644
--- a/nptl/allocatestack.c
+++ b/nptl/allocatestack.c
@@ -68,8 +68,9 @@ static LIST_HEAD (stack_cache);
 /* List of the stacks in use.  */
 static LIST_HEAD (stack_used);
 
-/* List of the threads with user provided stacks in use.  */
-LIST_HEAD (__stack_user);
+/* List of the threads with user provided stacks in use.  No need to
+   initialize this, since it's done in __pthread_initialize_minimal.  */
+list_t __stack_user __attribute__ ((nocommon));
 hidden_def (__stack_user)
 
 /* Number of threads running.  */
diff --git a/nptl/init.c b/nptl/init.c
index 395ede7033..d9c315c1da 100644
--- a/nptl/init.c
+++ b/nptl/init.c
@@ -123,8 +123,8 @@ __pthread_initialize_minimal (void)
   THREAD_SETMEM (pd, cpuclock_offset, GL(dl_cpuclock_offset));
 #endif
 
-  /* Add the main thread to the list of all running threads.  No need
-     to get the lock we are alone so far.  */
+  /* Initialize the list of all running threads with the main thread.  */
+  INIT_LIST_HEAD (__stack_user);
   list_add (&pd->header.data.list, &__stack_user);
 
 
diff --git a/nptl/sysdeps/i386/tls.h b/nptl/sysdeps/i386/tls.h
index 34783649b2..a4bbf3445a 100644
--- a/nptl/sysdeps/i386/tls.h
+++ b/nptl/sysdeps/i386/tls.h
@@ -204,7 +204,8 @@ union user_desc_init
 	  which is necessary since we have changed it.   */		      \
        TLS_SET_GS (_segdescr.desc.entry_number * 8 + 3);		      \
 									      \
-     _result; })
+     _result == 0 ? NULL						      \
+     : "set_thread_area failed when setting up thread-local storage"; })
 
 
 /* Return the address of the dtv for the current thread.  */
diff --git a/nptl/sysdeps/x86_64/tls.h b/nptl/sysdeps/x86_64/tls.h
index af3d202d5b..af4ad17abd 100644
--- a/nptl/sysdeps/x86_64/tls.h
+++ b/nptl/sysdeps/x86_64/tls.h
@@ -165,7 +165,8 @@ union user_desc_init
 		     "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.  */
diff --git a/sysdeps/generic/dl-tls.c b/sysdeps/generic/dl-tls.c
index 550de56530..725625d0fe 100644
--- a/sysdeps/generic/dl-tls.c
+++ b/sysdeps/generic/dl-tls.c
@@ -217,16 +217,13 @@ _dl_tls_setup (void)
 
   const size_t nelem = 2 + TLS_SLOTINFO_SURPLUS;
 
-  GL(dl_tls_dtv_slotinfo_list) =
-    malloc (sizeof (struct dtv_slotinfo_list)
-	    + nelem * sizeof (struct dtv_slotinfo));
+  GL(dl_tls_dtv_slotinfo_list)
+    = calloc (1, (sizeof (struct dtv_slotinfo_list)
+		  + nelem * sizeof (struct dtv_slotinfo)));
   if (GL(dl_tls_dtv_slotinfo_list) == NULL)
     return -1;
 
-  memset (GL(dl_tls_dtv_slotinfo_list)->slotinfo, '\0',
-	  nelem * sizeof (struct dtv_slotinfo));
   GL(dl_tls_dtv_slotinfo_list)->len = nelem;
-  GL(dl_tls_dtv_slotinfo_list)->next = NULL;
 
   /* Number of elements in the static TLS block.  It can't be zero
      because of various assumptions.  The one element is null.  */
@@ -251,14 +248,14 @@ 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 = (dtv_t *) malloc ((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.  */
       dtv[0].counter = dtv_length;
-      /* Initialize all of the rest of the dtv (including the
-	 generation counter) with zero to indicate nothing there.  */
-      memset (dtv + 1, '\0', (dtv_length + 1) * sizeof (dtv_t));
+
+      /* The rest of the dtv (including the generation counter) is
+	 Initialize with zero to indicate nothing there.  */
 
       /* Add the dtv to the thread data structures.  */
       INSTALL_DTV (result, dtv);
diff --git a/sysdeps/generic/libc-tls.c b/sysdeps/generic/libc-tls.c
index 756a2bf57c..5861e99e54 100644
--- a/sysdeps/generic/libc-tls.c
+++ b/sysdeps/generic/libc-tls.c
@@ -21,6 +21,7 @@
 #include <ldsodefs.h>
 #include <tls.h>
 #include <unistd.h>
+#include <stdio.h>
 
 #ifdef SHARED
  #error makefile bug, this file is for static only
@@ -168,8 +169,8 @@ __libc_setup_tls (size_t tcbsize, size_t tcbalign)
   /* Initialize the TLS block.  */
 # if TLS_TCB_AT_TP
   static_dtv[2].pointer = ((char *) tlsblock + tcb_offset
-			   - roundup (memsz, align));
-  static_map.l_tls_offset = roundup (memsz, align);
+			   - roundup (memsz, align ?: 1));
+  static_map.l_tls_offset = roundup (memsz, align ?: 1);
 # elif TLS_DTV_AT_TP
   tcb_offset = roundup (tcbsize, align);
   static_dtv[2].pointer = (char *) tlsblock + tcb_offset;
@@ -177,8 +178,10 @@ __libc_setup_tls (size_t tcbsize, size_t tcbalign)
 # else
 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 # endif
+  /* sbrk gives us zero'd memory, so we don't need this.
   memset (__mempcpy (static_dtv[2].pointer, initimage, filesz),
 	  '\0', memsz - filesz);
+  */
 
   /* Install the pointer to the dtv.  */
 
@@ -186,13 +189,15 @@ __libc_setup_tls (size_t tcbsize, size_t tcbalign)
 # if TLS_TCB_AT_TP
   INSTALL_DTV ((char *) tlsblock + tcb_offset, static_dtv);
 
-  TLS_INIT_TP ((char *) tlsblock + tcb_offset, 0);
+  const char *lossage = TLS_INIT_TP ((char *) tlsblock + tcb_offset, 0);
 # elif TLS_DTV_AT_TP
   INSTALL_DTV (tlsblock, static_dtv);
-  TLS_INIT_TP (tlsblock, 0);
+  const char *lossage = TLS_INIT_TP (tlsblock, 0);
 # else
 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 # endif
+  if (__builtin_expect (lossage != NULL, 0))
+    __libc_fatal (lossage);
 
   /* We have to create a fake link map which normally would be created
      by the dynamic linker.  It just has to have enough information to