2.5-18.1

1 files changed, 0 insertions, 220 deletions

diff --git a/linuxthreads/join.c b/linuxthreads/join.c
deleted file mode 100644
index 148f222319..0000000000
--- a/linuxthreads/join.c
+++ /dev/null
@@ -1,220 +0,0 @@
-/* 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 <errno.h>
-#include <sched.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include "pthread.h"
-#include "internals.h"
-#include "spinlock.h"
-#include "restart.h"
-#include <not-cancel.h>
-
-void __pthread_exit(void * retval)
-{
-  __pthread_do_exit (retval, CURRENT_STACK_FRAME);
-}
-strong_alias (__pthread_exit, pthread_exit);
-
-void __pthread_do_exit(void *retval, char *currentframe)
-{
-  pthread_descr self = thread_self();
-  pthread_descr joining;
-  struct pthread_request request;
-
-  /* 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(currentframe);
-  __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);
-  __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(write_not_cancel(__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);
-  }
-  /* Threads other than the main one  terminate without flushing stdio streams
-     or running 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;
-
-  /* Set up extrication interface */
-  extr.pu_object = handle;
-  extr.pu_extricate_func = join_extricate_func;
-
-  __pthread_lock(&handle->h_lock, self);
-  if (nonexisting_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_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
-    }
-
-    suspend(self);
-    /* 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_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
-    }
-    __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(write_not_cancel(__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 (nonexisting_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(write_not_cancel(__pthread_manager_request,
-					(char *) &request, sizeof(request)));
-  }
-  return 0;
-}