libpthread/

2005-05-04  Neal H. Walfield  <neal@gnu.org>

	* Makefile (SRCS): Add pt-thread_dealloc.c.
	* sysdeps/mach/pt-thread-dealloc.c: New file.
	* pthread/pt-internal.h (__pthread_thread_dealloc): New
	declaration.
	(__pthread_thread_halt): Add parameter NEED_DEALLOC.  Update
	callers.
	* sysdeps/mach/pt-thread-halt.c (__pthread_thread_halt): Respect
	new NEED_DEALLOC parameter.  Move code which deallocates kernel
	resources from here ...
	* sysdeps/mach/pt-thread-dealloc.c (__pthread_thread_dealloc):
	...to here.
	* pthread/pt-create.c (__pthread_create_internal): Call
	__pthread_thread_dealloc on failure.
	* pthread/pt-exit.c (pthread_exit): Call __pthread_thread_dealloc.

	* sysdeps/mach/pt-thread-alloc.c (create_wakeupmsg): Call
	__mach_port_destroy to deallocate the receive right.
	__mach_port_deallocate won't do it.

	* pthread/pt-detach.c (pthread_detach): Don't call
	__pthread_thread_halt a second time.

	* sysdeps/mach/hurd/pt-sysdep.c (_cthread_init_routine): Fix
	declaration.
	(init_routine): Update declaration and remove gratuitous cast.

4 files changed, 27 insertions, 13 deletions

diff --git a/pthread/pt-create.c b/pthread/pt-create.c
index cf5b32d8..bad5d83f 100644
--- a/pthread/pt-create.c
+++ b/pthread/pt-create.c
@@ -192,7 +192,8 @@ __pthread_create_internal (struct __pthread **thread,
  failed_sigstate:
   __pthread_sigstate_destroy (pthread);
  failed_setup:
-  __pthread_thread_halt (pthread);
+  __pthread_thread_dealloc (pthread);
+  __pthread_thread_halt (pthread, 0);
  failed_thread_alloc:
   __pthread_stack_dealloc (pthread->stackaddr, pthread->stacksize);
   pthread->stack = 0;
diff --git a/pthread/pt-detach.c b/pthread/pt-detach.c
index c22f6a03..42a84080 100644
--- a/pthread/pt-detach.c
+++ b/pthread/pt-detach.c
@@ -1,5 +1,5 @@
 /* Detach a thread.
-   Copyright (C) 2000 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2005 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -58,8 +58,6 @@ pthread_detach (pthread_t thread)
 
       __pthread_mutex_unlock (&pthread->state_lock);
 
-      __pthread_thread_halt (pthread);
-
       assert (pthread->stack);
       __pthread_stack_dealloc (pthread->stackaddr, pthread->stacksize);
       pthread->stack = 0;
diff --git a/pthread/pt-exit.c b/pthread/pt-exit.c
index fb9e97c0..7484ffd1 100644
--- a/pthread/pt-exit.c
+++ b/pthread/pt-exit.c
@@ -1,5 +1,5 @@
 /* Thread termination.
-   Copyright (C) 2000,02 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2002, 2005 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -35,6 +35,7 @@ pthread_exit (void *status)
   struct __pthread *self = _pthread_self ();
   struct __pthread_cancelation_handler **handlers;
   int oldstate;
+  int need_dealloc;
 
   /* Run any cancelation handlers.  According to POSIX, the
      cancellation cleanup handlers should be called with cancellation
@@ -69,10 +70,13 @@ pthread_exit (void *status)
   if (self->cancel_state == PTHREAD_CANCEL_ENABLE && self->cancel_pending)
     status = PTHREAD_CANCELED;
 
+  __pthread_thread_dealloc (self);
+
   switch (self->state)
     {
     default:
-      assert (! "This cannot happen!");
+      assert (! "Consistency error: unexpected self->state");
+      abort ();
       break;
 
     case PTHREAD_DETACHED:
@@ -82,7 +86,7 @@ pthread_exit (void *status)
          deallocate our own stack.  However, it will eventually be
          reused when this thread structure is recycled.  */
       __pthread_mutex_unlock (&self->state_lock);
-      __pthread_dealloc (self);
+      need_dealloc = 1;
 
       break;
 
@@ -99,6 +103,7 @@ pthread_exit (void *status)
          waiting to join us.  */
       pthread_cond_broadcast (&self->state_cond);
       __pthread_mutex_unlock (&self->state_lock);
+      need_dealloc = 0;
 
       break;
     }
@@ -108,7 +113,7 @@ pthread_exit (void *status)
      This means that before freeing any resources, such a thread
      should make sure that this thread is really halted.  */
   
-  __pthread_thread_halt (self);
+  __pthread_thread_halt (self, need_dealloc);
 
   /* NOTREACHED */
   abort ();
diff --git a/pthread/pt-internal.h b/pthread/pt-internal.h
index 75631db0..e9086956 100644
--- a/pthread/pt-internal.h
+++ b/pthread/pt-internal.h
@@ -195,16 +195,26 @@ extern int __pthread_setup (struct __pthread *thread,
 				  void *(*start_routine)(void *), void *arg);
 
 
-/* Allocate a kernel thread for THREAD; it must not be placed on the
-   run queue.  */
+/* Allocate a kernel thread (and any miscellaneous system dependent
+   resources) for THREAD; it must not be placed on the run queue.  */
 extern int __pthread_thread_alloc (struct __pthread *thread);
 
+/* Deallocate any kernel resources associated with THREAD except don't
+   halt the thread itself.  On return, the thread will be marked as
+   dead and __pthread_halt will be called.  */
+extern void __pthread_thread_dealloc (struct __pthread *thread);
+
 /* Start THREAD making it eligible to run.  */
 extern int __pthread_thread_start (struct __pthread *thread);
 
-/* Stop thread thread and deallocate any kernel resources associated
-   with THREAD.  */
-extern void __pthread_thread_halt (struct __pthread *thread);
+/* Stop the kernel thread associated with THREAD.  If NEED_DEALLOC is
+   true, the function must call __pthread_dealloc on THREAD.
+
+   NB: The thread executing this function may be the thread which is
+   being halted, thus the last action should be halting the thread
+   itself.  */
+extern void __pthread_thread_halt (struct __pthread *thread,
+				   int need_dealloc);
 
 
 /* Block THREAD.  */