aboutsummaryrefslogtreecommitdiff
path: root/linuxthreads
diff options
context:
space:
mode:
Diffstat (limited to 'linuxthreads')
-rw-r--r--linuxthreads/Examples/ex7.c40
-rw-r--r--linuxthreads/Makefile3
-rw-r--r--linuxthreads/internals.h2
-rw-r--r--linuxthreads/join.c8
-rw-r--r--linuxthreads/manager.c34
5 files changed, 80 insertions, 7 deletions
diff --git a/linuxthreads/Examples/ex7.c b/linuxthreads/Examples/ex7.c
new file mode 100644
index 0000000000..94b708b56b
--- /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 b51ea84f33..6e443631c3 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 b257be0279..e4cda4b66c 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 2716d799c1..7c9b6c5fd3 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 0c781dea6e..2d3e227f23 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