lib/libc_r/uthread/uthread_exit.c

   1 /*
   2  * Copyright (c) 1995-1998 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$
  33  */
  34 #include <errno.h>
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include "namespace.h"
  41 #include <pthread.h>
  42 #include "un-namespace.h"
  43 #include "pthread_private.h"
  44
  45 __weak_reference(_pthread_exit, pthread_exit);
  46
  47 void _exit(int status)
  48 {
  49         int             flags;
  50         int             i;
  51         struct itimerval itimer;
  52
  53         /* Disable the interval timer: */
  54         itimer.it_interval.tv_sec  = 0;
  55         itimer.it_interval.tv_usec = 0;
  56         itimer.it_value.tv_sec     = 0;
  57         itimer.it_value.tv_usec    = 0;
  58         setitimer(_ITIMER_SCHED_TIMER, &itimer, NULL);
  59
  60         /* Close the pthread kernel pipe: */
  61         __sys_close(_thread_kern_pipe[0]);
  62         __sys_close(_thread_kern_pipe[1]);
  63
  64         /*
  65          * Enter a loop to set all file descriptors to blocking
  66          * if they were not created as non-blocking:
  67          */
  68         for (i = 0; i < _thread_dtablesize; i++) {
  69                 /* Check if this file descriptor is in use: */
  70                 if (_thread_fd_table[i] != NULL &&
  71                     (_thread_fd_getflags(i) & O_NONBLOCK) == 0) {
  72                         /* Get the current flags: */
  73                         flags = __sys_fcntl(i, F_GETFL, NULL);
  74                         /* Clear the nonblocking file descriptor flag: */
  75                         __sys_fcntl(i, F_SETFL, flags & ~O_NONBLOCK);
  76                 }
  77         }
  78
  79         /* Call the _exit syscall: */
  80         __sys_exit(status);
  81 }
  82
  83 void
  84 _thread_exit(char *fname, int lineno, char *string)
  85 {
  86         char            s[256];
  87
  88         /* Prepare an error message string: */
  89         snprintf(s, sizeof(s),
  90             "Fatal error '%s' at line %d in file %s (errno = %d)\n",
  91             string, lineno, fname, errno);
  92
  93         /* Write the string to the standard error file descriptor: */
  94         __sys_write(2, s, strlen(s));
  95
  96         /* Force this process to exit: */
  97         /* XXX - Do we want abort to be conditional on _PTHREADS_INVARIANTS? */
  98 #if defined(_PTHREADS_INVARIANTS)
  99         abort();
 100 #else
 101         __sys_exit(1);
 102 #endif
 103 }
 104
 105 /*
 106  * Only called when a thread is cancelled.  It may be more useful
 107  * to call it from pthread_exit() if other ways of asynchronous or
 108  * abnormal thread termination can be found.
 109  */
 110 void
 111 _thread_exit_cleanup(void)
 112 {
 113         struct pthread  *curthread = _get_curthread();
 114
 115         /*
 116          * POSIX states that cancellation/termination of a thread should
 117          * not release any visible resources (such as mutexes) and that
 118          * it is the applications responsibility.  Resources that are
 119          * internal to the threads library, including file and fd locks,
 120          * are not visible to the application and need to be released.
 121          */
 122         /* Unlock all owned fd locks: */
 123         _thread_fd_unlock_owned(curthread);
 124
 125         /* Unlock all private mutexes: */
 126         _mutex_unlock_private(curthread);
 127
 128         /*
 129          * This still isn't quite correct because we don't account
 130          * for held spinlocks (see libc/stdlib/malloc.c).
 131          */
 132 }
 133
 134 void
 135 _pthread_exit(void *status)
 136 {
 137         struct pthread  *curthread = _get_curthread();
 138         pthread_t pthread;
 139
 140         /* Check if this thread is already in the process of exiting: */
 141         if ((curthread->flags & PTHREAD_EXITING) != 0) {
 142                 char msg[128];
 143                 snprintf(msg, sizeof(msg), "Thread %p has called pthread_exit() from a destructor. POSIX 1003.1 1996 s16.2.5.2 does not allow this!",curthread);
 144                 PANIC(msg);
 145         }
 146
 147         /* Flag this thread as exiting: */
 148         curthread->flags |= PTHREAD_EXITING;
 149
 150         /* Save the return value: */
 151         curthread->ret = status;
 152
 153         while (curthread->cleanup != NULL) {
 154                 pthread_cleanup_pop(1);
 155         }
 156         if (curthread->attr.cleanup_attr != NULL) {
 157                 curthread->attr.cleanup_attr(curthread->attr.arg_attr);
 158         }
 159         /* Check if there is thread specific data: */
 160         if (curthread->specific != NULL) {
 161                 /* Run the thread-specific data destructors: */
 162                 _thread_cleanupspecific();
 163         }
 164
 165         /* Free thread-specific poll_data structure, if allocated: */
 166         if (curthread->poll_data.fds != NULL) {
 167                 free(curthread->poll_data.fds);
 168                 curthread->poll_data.fds = NULL;
 169         }
 170
 171         /*
 172          * Lock the garbage collector mutex to ensure that the garbage
 173          * collector is not using the dead thread list.
 174          */
 175         if (_pthread_mutex_lock(&_gc_mutex) != 0)
 176                 PANIC("Cannot lock gc mutex");
 177
 178         /* Add this thread to the list of dead threads. */
 179         TAILQ_INSERT_HEAD(&_dead_list, curthread, dle);
 180
 181         /*
 182          * Signal the garbage collector thread that there is something
 183          * to clean up.
 184          */
 185         if (_pthread_cond_signal(&_gc_cond) != 0)
 186                 PANIC("Cannot signal gc cond");
 187
 188         /*
 189          * Avoid a race condition where a scheduling signal can occur
 190          * causing the garbage collector thread to run.  If this happens,
 191          * the current thread can be cleaned out from under us.
 192          */
 193         _thread_kern_sig_defer();
 194
 195         /* Unlock the garbage collector mutex: */
 196         if (_pthread_mutex_unlock(&_gc_mutex) != 0)
 197                 PANIC("Cannot unlock gc mutex");
 198
 199         /* Check if there is a thread joining this one: */
 200         if (curthread->joiner != NULL) {
 201                 pthread = curthread->joiner;
 202                 curthread->joiner = NULL;
 203
 204                 /* Make the joining thread runnable: */
 205                 PTHREAD_NEW_STATE(pthread, PS_RUNNING);
 206
 207                 /* Set the return value for the joining thread: */
 208                 pthread->join_status.ret = curthread->ret;
 209                 pthread->join_status.error = 0;
 210                 pthread->join_status.thread = NULL;
 211
 212                 /* Make this thread collectable by the garbage collector. */
 213                 PTHREAD_ASSERT(((curthread->attr.flags & PTHREAD_DETACHED) ==
 214                     0), "Cannot join a detached thread");
 215                 curthread->attr.flags |= PTHREAD_DETACHED;
 216         }
 217
 218         /* Remove this thread from the thread list: */
 219         TAILQ_REMOVE(&_thread_list, curthread, tle);
 220
 221         /* This thread will never be re-scheduled. */
 222         _thread_kern_sched_state(PS_DEAD, __FILE__, __LINE__);
 223
 224         /* This point should not be reached. */
 225         PANIC("Dead thread has resumed");
 226 }