From 45eca4d141c047950db48c69c8941163d0a61fcd Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Sun, 7 May 2000 21:23:56 +0000 Subject: Update. 2000-05-06 Bruno Haible * iconv/gconv_open.c (__gconv_open): If __gconv_find_transform returned != __GCONV_OK, there is nothing to clean up. 2000-05-06 Bruno Haible * intl/tst-gettext.c (main): Disable possibly existing LC_CTYPE and OUTPUT_CHARSET environment variables. 2000-05-06 Andreas Jaeger * 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 * 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 * intl/dcigettext.c (dcigettext): Fix interpretation of tsearch return value. --- linuxthreads/Examples/ex7.c | 40 ++++++++++++++++++++++++++++++++++++++++ linuxthreads/Makefile | 3 ++- linuxthreads/internals.h | 2 +- linuxthreads/join.c | 8 ++++++-- linuxthreads/manager.c | 34 +++++++++++++++++++++++++++++++--- 5 files changed, 80 insertions(+), 7 deletions(-) create mode 100644 linuxthreads/Examples/ex7.c (limited to 'linuxthreads') 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 +#include +#include + +#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 -- cgit v1.1