summaryrefslogtreecommitdiff
path: root/libpthread/linuxthreads.old/join.c
diff options
context:
space:
mode:
authorMike Frysinger <vapier@gentoo.org>2005-11-15 03:13:04 +0000
committerMike Frysinger <vapier@gentoo.org>2005-11-15 03:13:04 +0000
commita9f5aa1cc96fc2c71f19a9c3e9dcbee0e78f83ca (patch)
tree2c5d251bdfd06d0a76cec9fc507b1873b4bbbdad /libpthread/linuxthreads.old/join.c
parentfd6dde5a19092be5bb1990dadd5c595d2ed0b3aa (diff)
rename current stable linuxthreads to linuxthreads.old to prepare for import of latest glibc version
Diffstat (limited to 'libpthread/linuxthreads.old/join.c')
-rw-r--r--libpthread/linuxthreads.old/join.c221
1 files changed, 221 insertions, 0 deletions
diff --git a/libpthread/linuxthreads.old/join.c b/libpthread/linuxthreads.old/join.c
new file mode 100644
index 000000000..5aeec6a20
--- /dev/null
+++ b/libpthread/linuxthreads.old/join.c
@@ -0,0 +1,221 @@
+/* Linuxthreads - a simple clone()-based implementation of Posix */
+/* threads for Linux. */
+/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */
+/* */
+/* This program is free software; you can redistribute it and/or */
+/* modify it under the terms of the GNU Library General Public License */
+/* as published by the Free Software Foundation; either version 2 */
+/* of the License, or (at your option) any later version. */
+/* */
+/* This program is distributed in the hope that it will be useful, */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
+/* GNU Library General Public License for more details. */
+
+/* Thread termination and joining */
+
+#include <features.h>
+#define __USE_GNU
+#include <errno.h>
+#include <sched.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include "pthread.h"
+#include "internals.h"
+#include "spinlock.h"
+#include "restart.h"
+#include "debug.h" /* PDEBUG, added by StS */
+
+void pthread_exit(void * retval)
+{
+ pthread_descr self = thread_self();
+ pthread_descr joining;
+ struct pthread_request request;
+ PDEBUG("self=%p, pid=%d\n", self, self->p_pid);
+
+ /* Reset the cancellation flag to avoid looping if the cleanup handlers
+ contain cancellation points */
+ THREAD_SETMEM(self, p_canceled, 0);
+ /* Call cleanup functions and destroy the thread-specific data */
+ __pthread_perform_cleanup();
+ __pthread_destroy_specifics();
+ /* Store return value */
+ __pthread_lock(THREAD_GETMEM(self, p_lock), self);
+ THREAD_SETMEM(self, p_retval, retval);
+ /* See whether we have to signal the death. */
+ if (THREAD_GETMEM(self, p_report_events))
+ {
+ /* See whether TD_DEATH is in any of the mask. */
+ int idx = __td_eventword (TD_DEATH);
+ uint32_t mask = __td_eventmask (TD_DEATH);
+
+ if ((mask & (__pthread_threads_events.event_bits[idx]
+ | THREAD_GETMEM_NC(self,
+ p_eventbuf.eventmask).event_bits[idx]))
+ != 0)
+ {
+ /* Yep, we have to signal the death. */
+ THREAD_SETMEM(self, p_eventbuf.eventnum, TD_DEATH);
+ THREAD_SETMEM(self, p_eventbuf.eventdata, self);
+ __pthread_last_event = self;
+
+ /* Now call the function to signal the event. */
+ __linuxthreads_death_event();
+ }
+ }
+ /* Say that we've terminated */
+ THREAD_SETMEM(self, p_terminated, 1);
+ /* See if someone is joining on us */
+ joining = THREAD_GETMEM(self, p_joining);
+ PDEBUG("joining = %p, pid=%d\n", joining, joining->p_pid);
+ __pthread_unlock(THREAD_GETMEM(self, p_lock));
+ /* Restart joining thread if any */
+ if (joining != NULL) restart(joining);
+ /* If this is the initial thread, block until all threads have terminated.
+ If another thread calls exit, we'll be terminated from our signal
+ handler. */
+ if (self == __pthread_main_thread && __pthread_manager_request >= 0) {
+ request.req_thread = self;
+ request.req_kind = REQ_MAIN_THREAD_EXIT;
+ TEMP_FAILURE_RETRY(__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). */
+ _exit(0);
+}
+
+/* Function called by pthread_cancel to remove the thread from
+ waiting on a condition variable queue. */
+
+static int join_extricate_func(void *obj, pthread_descr th)
+{
+ volatile pthread_descr self = thread_self();
+ pthread_handle handle = obj;
+ pthread_descr jo;
+ int did_remove = 0;
+
+ __pthread_lock(&handle->h_lock, self);
+ jo = handle->h_descr;
+ did_remove = jo->p_joining != NULL;
+ jo->p_joining = NULL;
+ __pthread_unlock(&handle->h_lock);
+
+ return did_remove;
+}
+
+int pthread_join(pthread_t thread_id, void ** thread_return)
+{
+ volatile pthread_descr self = thread_self();
+ struct pthread_request request;
+ pthread_handle handle = thread_handle(thread_id);
+ pthread_descr th;
+ pthread_extricate_if extr;
+ int already_canceled = 0;
+ PDEBUG("\n");
+
+ /* Set up extrication interface */
+ extr.pu_object = handle;
+ extr.pu_extricate_func = join_extricate_func;
+
+ __pthread_lock(&handle->h_lock, self);
+ if (invalid_handle(handle, thread_id)) {
+ __pthread_unlock(&handle->h_lock);
+ return ESRCH;
+ }
+ th = handle->h_descr;
+ if (th == self) {
+ __pthread_unlock(&handle->h_lock);
+ return EDEADLK;
+ }
+ /* If detached or already joined, error */
+ if (th->p_detached || th->p_joining != NULL) {
+ __pthread_unlock(&handle->h_lock);
+ return EINVAL;
+ }
+ /* If not terminated yet, suspend ourselves. */
+ if (! th->p_terminated) {
+ /* Register extrication interface */
+ __pthread_set_own_extricate_if(self, &extr);
+ if (!(THREAD_GETMEM(self, p_canceled)
+ && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))
+ th->p_joining = self;
+ else
+ already_canceled = 1;
+ __pthread_unlock(&handle->h_lock);
+
+ if (already_canceled) {
+ __pthread_set_own_extricate_if(self, 0);
+ pthread_exit(PTHREAD_CANCELED);
+ }
+
+ PDEBUG("before suspend\n");
+ suspend(self);
+ PDEBUG("after suspend\n");
+ /* Deregister extrication interface */
+ __pthread_set_own_extricate_if(self, 0);
+
+ /* This is a cancellation point */
+ if (THREAD_GETMEM(self, p_woken_by_cancel)
+ && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
+ THREAD_SETMEM(self, p_woken_by_cancel, 0);
+ pthread_exit(PTHREAD_CANCELED);
+ }
+ __pthread_lock(&handle->h_lock, self);
+ }
+ /* Get return value */
+ if (thread_return != NULL) *thread_return = th->p_retval;
+ __pthread_unlock(&handle->h_lock);
+ /* Send notification to thread manager */
+ if (__pthread_manager_request >= 0) {
+ request.req_thread = self;
+ request.req_kind = REQ_FREE;
+ request.req_args.free.thread_id = thread_id;
+ TEMP_FAILURE_RETRY(__libc_write(__pthread_manager_request,
+ (char *) &request, sizeof(request)));
+ }
+ return 0;
+}
+
+int pthread_detach(pthread_t thread_id)
+{
+ int terminated;
+ struct pthread_request request;
+ pthread_handle handle = thread_handle(thread_id);
+ pthread_descr th;
+
+ __pthread_lock(&handle->h_lock, NULL);
+ if (invalid_handle(handle, thread_id)) {
+ __pthread_unlock(&handle->h_lock);
+ return ESRCH;
+ }
+ th = handle->h_descr;
+ /* If already detached, error */
+ if (th->p_detached) {
+ __pthread_unlock(&handle->h_lock);
+ return EINVAL;
+ }
+ /* If already joining, don't do anything. */
+ if (th->p_joining != NULL) {
+ __pthread_unlock(&handle->h_lock);
+ return 0;
+ }
+ /* Mark as detached */
+ th->p_detached = 1;
+ terminated = th->p_terminated;
+ __pthread_unlock(&handle->h_lock);
+ /* If already terminated, notify thread manager to reclaim resources */
+ if (terminated && __pthread_manager_request >= 0) {
+ request.req_thread = thread_self();
+ request.req_kind = REQ_FREE;
+ request.req_args.free.thread_id = thread_id;
+ TEMP_FAILURE_RETRY(__libc_write(__pthread_manager_request,
+ (char *) &request, sizeof(request)));
+ }
+ return 0;
+}