Update.

2000-05-06  Bruno Haible  <haible@clisp.cons.org>

	* iconv/gconv_open.c (__gconv_open): If __gconv_find_transform
	returned != __GCONV_OK, there is nothing to clean up.

2000-05-06  Bruno Haible  <haible@clisp.cons.org>

	* intl/tst-gettext.c (main): Disable possibly existing LC_CTYPE and
	OUTPUT_CHARSET environment variables.

2000-05-06  Andreas Jaeger  <aj@suse.de>

	* sysdeps/generic/dl-cache.h (struct file_entry_new): New.
	(struct cache_file_new): New.
	(struct file_entry): New (moved from cache.c).
	(struct cache_file): New (moved from cache.c).

	* sysdeps/generic/dl-cache.c (SEARCH_CACHE): New macro, broken out
	from _dl_load_cache_lookup.
	(_dl_load_cache_lookup): Move search to SEARCH_CACHE macro, handle
	the different cache formats.
	New variable cache_new for new format.

	* elf/ldconfig.h: Change according to changes in cache.c and
	ldconfig.c; remove cache_libcmp; add opt_format.

	* elf/ldconfig.c: Include "dl-cache.h" and "dl-procinfo.h"; remove
	stuff that's defined in those headers.
	Add hwcap to struct lib_entry.
	(opt_format): New variable to select cache format.
	(options): Add format parameter.
	(is_hwcap): New function.
	(path_hwcap): New function.
	(parse_opt): Handle new format parameter.
	(search_dir): Handle hwcap, search also subdirectories with hwcap.

	* elf/cache.c (_GNU_SOURCE): Removed.  Not needed anymore since
	ldconfig is part of glibc.
	Include dl-cache.h and remove stuff that's defined there.
	(struct cache_entry): Add new member hwcap.
	(print_entry): Print hwcap, cleanup a bit.
	(print_cache): Print new and old formats.
	(compare): Use _dl_cache_libcmp from dl-cache.h; handle hwcap.
	(save_cache): Save new and old formats.
	(add_to_cache): Handle hwcap.

	* sysdeps/generic/dl-cache.c (_dl_cache_libcmp): Moved from here...
	* sysdeps/generic/dl-cache.h (_dl_cache_libcmp): ...to here.
	* sysdeps/generic/dl-cache.c (LD_SO_CACHE): Moved from here...
	* sysdeps/generic/dl-cache.h (LD_SO_CACHE): ...to here.
	* sysdeps/generic/dl-cache.c (CACHEMAGIC): Moved from here...
	* sysdeps/generic/dl-cache.h (CACHEMAGIC): ...to here.

2000-05-05  Bruno Haible  <haible@clisp.cons.org>

	* intl/dcigettext.c (alignof): New macro.
	(_nl_find_msg): Use it instead of __alignof__. Pass correct output
	buffer length to __gconv/iconv. If malloc (freemem_size) fails, set
	freemem_size to 0.

2000-05-05  Bruno Haible  <haible@clisp.cons.org>

	* intl/dcigettext.c (dcigettext): Fix interpretation of tsearch
	return value.

5 files changed, 80 insertions, 7 deletions

diff --git a/linuxthreads/Examples/ex7.c b/linuxthreads/Examples/ex7.c
new file mode 100644
index 0000000..94b708b
--- /dev/null
+++ b/linuxthreads/Examples/ex7.c
@@ -0,0 +1,40 @@
+/* This is a test of the special shutdown that occurs
+   when all threads, including the main one, call
+   pthread_exit(). It demonstrates that atexit
+   handlers are properly called, and that the
+   output is properly flushed even when stdout is
+   redirected to a file, and therefore fully buffered. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+#define NTHREADS 20	/* number of threads */
+
+static void *thread(void *arg)
+{
+  printf("thread terminating\n");
+  return 0;
+}
+
+void cleanup(void)
+{
+  printf("atexit handler called\n");
+}
+
+int main(void)
+{
+  int i;
+
+  atexit(cleanup);
+
+  for (i = 0; i < NTHREADS; i++) {
+    pthread_t id;
+    if (pthread_create(&id, 0, thread, 0) != 0) {
+      fprintf(stderr, "pthread_create failed\n");
+      abort();
+    }
+  }
+
+  pthread_exit(0);
+}
diff --git a/linuxthreads/Makefile b/linuxthreads/Makefile
index b51ea84..6e44363 100644
--- a/linuxthreads/Makefile
+++ b/linuxthreads/Makefile
@@ -38,7 +38,7 @@ libpthread-routines := attr cancel condvar join manager mutex ptfork \
 		       oldsemaphore events getcpuclockid
 
 vpath %.c Examples
-tests = ex1 ex2 ex3 ex4 ex5 ex6
+tests = ex1 ex2 ex3 ex4 ex5 ex6 ex7
 
 include ../Rules
 
@@ -66,3 +66,4 @@ $(objpfx)ex3: $(libpthread)
 $(objpfx)ex4: $(libpthread)
 $(objpfx)ex5: $(libpthread)
 $(objpfx)ex6: $(libpthread)
+$(objpfx)ex7: $(libpthread)
diff --git a/linuxthreads/internals.h b/linuxthreads/internals.h
index b257be0..e4cda4b 100644
--- a/linuxthreads/internals.h
+++ b/linuxthreads/internals.h
@@ -199,7 +199,7 @@ struct pthread_request {
   pthread_descr req_thread;     /* Thread doing the request */
   enum {                        /* Request kind */
     REQ_CREATE, REQ_FREE, REQ_PROCESS_EXIT, REQ_MAIN_THREAD_EXIT,
-    REQ_POST, REQ_DEBUG
+    REQ_POST, REQ_DEBUG, REQ_KICK
   } req_kind;
   union {                       /* Arguments for request */
     struct {                    /* For REQ_CREATE: */
diff --git a/linuxthreads/join.c b/linuxthreads/join.c
index 2716d79..7c9b6c5 100644
--- a/linuxthreads/join.c
+++ b/linuxthreads/join.c
@@ -73,9 +73,13 @@ void pthread_exit(void * retval)
     request.req_kind = REQ_MAIN_THREAD_EXIT;
     __libc_write(__pthread_manager_request, (char *)&request, sizeof(request));
     suspend(self);
+    /* Main thread flushes stdio streams and runs atexit functions.
+       It also calls a handler within LinuxThreads which sends a process exit
+       request to the thread manager. */
+    exit(0); 
   }
-  /* Exit the process (but don't flush stdio streams, and don't run
-     atexit functions). */
+  /* Threads other than the main one  terminate without flushing stdio streams
+     or running atexit functions. */
   _exit(0);
 }
 
diff --git a/linuxthreads/manager.c b/linuxthreads/manager.c
index 0c781de..2d3e227 100644
--- a/linuxthreads/manager.c
+++ b/linuxthreads/manager.c
@@ -162,13 +162,22 @@ int __pthread_manager(void *arg)
       case REQ_PROCESS_EXIT:
         pthread_handle_exit(request.req_thread,
                             request.req_args.exit.code);
+	/* NOTREACHED */
         break;
       case REQ_MAIN_THREAD_EXIT:
         main_thread_exiting = 1;
+	/* Reap children in case all other threads died and the signal handler
+	   went off before we set main_thread_exiting to 1, and therefore did
+	   not do REQ_KICK. */
+	pthread_reap_children();
+
         if (__pthread_main_thread->p_nextlive == __pthread_main_thread) {
           restart(__pthread_main_thread);
-          return 0;
-        }
+	  /* The main thread will now call exit() which will trigger an
+	     __on_exit handler, which in turn will send REQ_PROCESS_EXIT
+	     to the thread manager. In case you are wondering how the
+	     manager terminates from its loop here. */
+	}	      
         break;
       case REQ_POST:
         __new_sem_post(request.req_args.post);
@@ -179,6 +188,10 @@ int __pthread_manager(void *arg)
 	if (__pthread_threads_debug && __pthread_sig_debug > 0)
 	  raise(__pthread_sig_debug);
         break;
+      case REQ_KICK:
+	/* This is just a prod to get the manager to reap some
+	   threads right away, avoiding a potential delay at shutdown. */
+	break;
       }
     }
   }
@@ -591,7 +604,7 @@ static void pthread_exited(pid_t pid)
   if (main_thread_exiting &&
       __pthread_main_thread->p_nextlive == __pthread_main_thread) {
     restart(__pthread_main_thread);
-    _exit(0);
+    /* Same logic as REQ_MAIN_THREAD_EXIT. */
   }
 }
 
@@ -685,7 +698,22 @@ static void pthread_handle_exit(pthread_descr issuing_thread, int exitcode)
 
 void __pthread_manager_sighandler(int sig)
 {
+  int kick_manager = terminated_children == 0 && main_thread_exiting;
   terminated_children = 1;
+
+  /* If the main thread is terminating, kick the thread manager loop
+     each time some threads terminate. This eliminates a two second
+     shutdown delay caused by the thread manager sleeping in the
+     call to __poll(). Instead, the thread manager is kicked into
+     action, reaps the outstanding threads and resumes the main thread
+     so that it can complete the shutdown. */
+
+  if (kick_manager) {
+    struct pthread_request request;
+    request.req_thread = 0;
+    request.req_kind = REQ_KICK;
+    __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));
+  }
 }
 
 /* Adjust priority of thread manager so that it always run at a priority