lib/libc_r/uthread/uthread_join.c

   1 /*
   2  * Copyright (c) 1995 John Birrell <jb@cimlogic.com.au>.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by John Birrell.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/lib/libc_r/uthread/uthread_join.c,v 1.12.2.8 2002/10/22 14:44:03 fjoe Exp $
  33  * $DragonFly: src/lib/libc_r/uthread/uthread_join.c,v 1.2 2003/06/17 04:26:48 dillon Exp $
  34  */
  35 #include <errno.h>
  36 #include <pthread.h>
  37 #include "pthread_private.h"
  38
  39 __weak_reference(_pthread_join, pthread_join);
  40
  41 int
  42 _pthread_join(pthread_t pthread, void **thread_return)
  43 {
  44         struct pthread  *curthread = _get_curthread();
  45         int ret = 0;
  46         pthread_t thread;
  47
  48         _thread_enter_cancellation_point();
  49
  50         /* Check if the caller has specified an invalid thread: */
  51         if (pthread == NULL || pthread->magic != PTHREAD_MAGIC) {
  52                 /* Invalid thread: */
  53                 _thread_leave_cancellation_point();
  54                 return(EINVAL);
  55         }
  56
  57         /* Check if the caller has specified itself: */
  58         if (pthread == curthread) {
  59                 /* Avoid a deadlock condition: */
  60                 _thread_leave_cancellation_point();
  61                 return(EDEADLK);
  62         }
  63
  64         /*
  65          * Lock the garbage collector mutex to ensure that the garbage
  66          * collector is not using the dead thread list.
  67          */
  68         if (pthread_mutex_lock(&_gc_mutex) != 0)
  69                 PANIC("Cannot lock gc mutex");
  70
  71         /*
  72          * Defer signals to protect the thread list from access
  73          * by the signal handler:
  74          */
  75         _thread_kern_sig_defer();
  76
  77         /*
  78          * Unlock the garbage collector mutex, now that the garbage collector
  79          * can't be run:
  80          */
  81         if (pthread_mutex_unlock(&_gc_mutex) != 0)
  82                 PANIC("Cannot lock gc mutex");
  83
  84         /*
  85          * Search for the specified thread in the list of active threads.  This
  86          * is done manually here rather than calling _find_thread() because
  87          * the searches in _thread_list and _dead_list (as well as setting up
  88          * join/detach state) have to be done atomically.
  89          */
  90         TAILQ_FOREACH(thread, &_thread_list, tle) {
  91                 if (thread == pthread)
  92                         break;
  93         }
  94         if (thread == NULL) {
  95                 /*
  96                  * Search for the specified thread in the list of dead threads:
  97                  */
  98                 TAILQ_FOREACH(thread, &_dead_list, dle) {
  99                         if (thread == pthread)
 100                                 break;
 101                 }
 102         }
 103
 104         /* Check if the thread was not found or has been detached: */
 105         if (thread == NULL ||
 106             ((pthread->attr.flags & PTHREAD_DETACHED) != 0)) {
 107                 /* Undefer and handle pending signals, yielding if necessary: */
 108                 _thread_kern_sig_undefer();
 109
 110                 /* Return an error: */
 111                 ret = ESRCH;
 112
 113         } else if (pthread->joiner != NULL) {
 114                 /* Undefer and handle pending signals, yielding if necessary: */
 115                 _thread_kern_sig_undefer();
 116
 117                 /* Multiple joiners are not supported. */
 118                 ret = ENOTSUP;
 119
 120         /* Check if the thread is not dead: */
 121         } else if (pthread->state != PS_DEAD) {
 122                 /* Set the running thread to be the joiner: */
 123                 pthread->joiner = curthread;
 124
 125                 /* Keep track of which thread we're joining to: */
 126                 curthread->join_status.thread = pthread;
 127
 128                 while (curthread->join_status.thread == pthread) {
 129                         /* Schedule the next thread: */
 130                         _thread_kern_sched_state(PS_JOIN, __FILE__, __LINE__);
 131                 }
 132
 133                 /*
 134                  * The thread return value and error are set by the thread we're
 135                  * joining to when it exits or detaches:
 136                  */
 137                 ret = curthread->join_status.error;
 138                 if ((ret == 0) && (thread_return != NULL))
 139                         *thread_return = curthread->join_status.ret;
 140         } else {
 141                 /*
 142                  * The thread exited (is dead) without being detached, and no
 143                  * thread has joined it.
 144                  */
 145
 146                 /* Check if the return value is required: */
 147                 if (thread_return != NULL) {
 148                         /* Return the thread's return value: */
 149                         *thread_return = pthread->ret;
 150                 }
 151
 152                 /* Make the thread collectable by the garbage collector. */
 153                 pthread->attr.flags |= PTHREAD_DETACHED;
 154
 155                 /* Undefer and handle pending signals, yielding if necessary: */
 156                 _thread_kern_sig_undefer();
 157         }
 158
 159         _thread_leave_cancellation_point();
 160
 161         /* Return the completion status: */
 162         return (ret);
 163 }