Cleanup the TLS implementation:
[dragonfly.git] / lib / libthread_xu / thread / thr_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: src/lib/libpthread/thread/thr_exit.c,v 1.39 2004/10/23 23:37:54 davidxu Exp $
33  * $DragonFly: src/lib/libthread_xu/thread/thr_exit.c,v 1.2 2005/03/29 19:26:20 joerg Exp $
34  */
35
36 #include <machine/tls.h>
37
38 #include <errno.h>
39 #include <unistd.h>
40 #include <fcntl.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <pthread.h>
45 #include "thr_private.h"
46
47 void    _pthread_exit(void *status);
48
49 __weak_reference(_pthread_exit, pthread_exit);
50
51 void
52 _thread_exit(char *fname, int lineno, char *msg)
53 {
54
55         /* Write an error message to the standard error file descriptor: */
56         _thread_printf(2,
57             "Fatal error '%s' at line %d in file %s (errno = %d)\n",
58             msg, lineno, fname, errno);
59
60         abort();
61 }
62
63 /*
64  * Only called when a thread is cancelled.  It may be more useful
65  * to call it from pthread_exit() if other ways of asynchronous or
66  * abnormal thread termination can be found.
67  */
68 void
69 _thr_exit_cleanup(void)
70 {
71         struct pthread  *curthread = tls_get_curthread();
72
73         /*
74          * POSIX states that cancellation/termination of a thread should
75          * not release any visible resources (such as mutexes) and that
76          * it is the applications responsibility.  Resources that are
77          * internal to the threads library, including file and fd locks,
78          * are not visible to the application and need to be released.
79          */
80         /* Unlock all private mutexes: */
81         _mutex_unlock_private(curthread);
82
83         /*
84          * This still isn't quite correct because we don't account
85          * for held spinlocks (see libc/stdlib/malloc.c).
86          */
87 }
88
89 void
90 _pthread_exit(void *status)
91 {
92         struct pthread *curthread = tls_get_curthread();
93
94         /* Check if this thread is already in the process of exiting: */
95         if ((curthread->cancelflags & THR_CANCEL_EXITING) != 0) {
96                 char msg[128];
97                 snprintf(msg, sizeof(msg), "Thread %p has called "
98                     "pthread_exit() from a destructor. POSIX 1003.1 "
99                     "1996 s16.2.5.2 does not allow this!", curthread);
100                 PANIC(msg);
101         }
102
103         /* Flag this thread as exiting. */
104         atomic_set_int(&curthread->cancelflags, THR_CANCEL_EXITING);
105         
106         _thr_exit_cleanup();
107
108         /* Save the return value: */
109         curthread->ret = status;
110         while (curthread->cleanup != NULL) {
111                 pthread_cleanup_pop(1);
112         }
113         if (curthread->attr.cleanup_attr != NULL) {
114                 curthread->attr.cleanup_attr(curthread->attr.arg_attr);
115         }
116         /* Check if there is thread specific data: */
117         if (curthread->specific != NULL) {
118                 /* Run the thread-specific data destructors: */
119                 _thread_cleanupspecific();
120         }
121
122         if (!_thr_isthreaded())
123                 exit(0);
124
125         THREAD_LIST_LOCK(curthread);
126         _thread_active_threads--;
127         if (_thread_active_threads == 0) {
128                 THREAD_LIST_UNLOCK(curthread);
129                 exit(0);
130                 /* Never reach! */
131         }
132         if (curthread->tlflags & TLFLAGS_DETACHED)
133                 THR_GCLIST_ADD(curthread);
134         curthread->state = PS_DEAD;
135         THREAD_LIST_UNLOCK(curthread);
136         if (curthread->joiner)
137                 _thr_umtx_wake(&curthread->state, INT_MAX);
138         /* XXX
139          * All the code is incorrect on DragonFly.
140          * DragonFly has race condition here. it should provide
141          * an interface to tell userland that a thread is now
142          * in kernel, and userland stack can be safely recycled
143          * by userland GC code.
144          */
145         curthread->terminated = 1;
146         _exit(0);
147         PANIC("thr_exit() returned");
148         /* Never reach! */
149 }