Add support for TLS.
[dragonfly.git] / lib / libc_r / uthread / uthread_gc.c
1 /*
2  * Copyright (c) 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/libc_r/uthread/uthread_gc.c,v 1.11.2.5 2002/10/22 14:44:03 fjoe Exp $
33  * $DragonFly: src/lib/libc_r/uthread/uthread_gc.c,v 1.3 2005/04/28 18:16:47 joerg Exp $
34  *
35  * Garbage collector thread. Frees memory allocated for dead threads.
36  *
37  */
38 #include <errno.h>
39 #include <time.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42 #include <sys/types.h>
43 #include <sys/types.h>
44 #include <sys/mman.h>
45 #include <pthread.h>
46 #include "pthread_private.h"
47
48 pthread_addr_t
49 _thread_gc(pthread_addr_t arg)
50 {
51         struct pthread  *curthread = _get_curthread();
52         int             f_debug;
53         int             f_done = 0;
54         int             ret;
55         sigset_t        mask;
56         pthread_t       pthread;
57         pthread_t       pthread_cln;
58         struct timespec abstime;
59         void            *p_stack;
60
61         /* Block all signals */
62         sigfillset(&mask);
63         pthread_sigmask(SIG_BLOCK, &mask, NULL);
64
65         /* Mark this thread as a library thread (not a user thread). */
66         curthread->flags |= PTHREAD_FLAGS_PRIVATE;
67
68         /* Set a debug flag based on an environment variable. */
69         f_debug = (getenv("LIBC_R_DEBUG") != NULL);
70
71         /* Set the name of this thread. */
72         pthread_set_name_np(curthread,"GC");
73
74         while (!f_done) {
75                 /* Check if debugging this application. */
76                 if (f_debug)
77                         /* Dump thread info to file. */
78                         _thread_dump_info();
79
80                 /*
81                  * Defer signals to protect the scheduling queues from
82                  * access by the signal handler:
83                  */
84                 _thread_kern_sig_defer();
85
86                 /* Check if this is the last running thread: */
87                 if (TAILQ_FIRST(&_thread_list) == curthread &&
88                     TAILQ_NEXT(curthread, tle) == NULL)
89                         /*
90                          * This is the last thread, so it can exit
91                          * now.
92                          */
93                         f_done = 1;
94
95                 /*
96                  * Undefer and handle pending signals, yielding if
97                  * necessary:
98                  */
99                 _thread_kern_sig_undefer();
100
101                 /*
102                  * Lock the garbage collector mutex which ensures that
103                  * this thread sees another thread exit:
104                  */
105                 if (pthread_mutex_lock(&_gc_mutex) != 0)
106                         PANIC("Cannot lock gc mutex");
107
108                 /* No stack of thread structure to free yet: */
109                 p_stack = NULL;
110                 pthread_cln = NULL;
111
112                 /*
113                  * Enter a loop to search for the first dead thread that
114                  * has memory to free.
115                  */
116                 for (pthread = TAILQ_FIRST(&_dead_list);
117                      p_stack == NULL && pthread_cln == NULL && pthread != NULL;
118                      pthread = TAILQ_NEXT(pthread, dle)) {
119                         /* Check if the initial thread: */
120                         if (pthread == _thread_initial) {
121                                 /* Don't destroy the initial thread. */
122                         }
123                         /*
124                          * Check if this thread has detached:
125                          */
126                         else if ((pthread->attr.flags &
127                             PTHREAD_DETACHED) != 0) {
128                                 /* Remove this thread from the dead list: */
129                                 TAILQ_REMOVE(&_dead_list, pthread, dle);
130
131                                 /*
132                                  * Check if the stack was not specified by
133                                  * the caller to pthread_create() and has not
134                                  * been destroyed yet: 
135                                  */
136                                 if (pthread->attr.stackaddr_attr == NULL &&
137                                     pthread->stack != NULL) {
138                                         if (pthread->attr.stacksize_attr
139                                             == PTHREAD_STACK_DEFAULT) {
140                                                 /*
141                                                  * Default-size stack.  Cache
142                                                  * it:
143                                                  */
144                                                 struct stack    *spare_stack;
145
146                                                 spare_stack
147                                                     = (pthread->stack
148                                                        + PTHREAD_STACK_DEFAULT
149                                                        - sizeof(struct stack));
150                                                 SLIST_INSERT_HEAD(&_stackq,
151                                                                   spare_stack,
152                                                                   qe);
153                                         } else {
154                                                 /*
155                                                  * Non-standard stack size.
156                                                  * free() it outside the locks.
157                                                  */
158                                                 p_stack = pthread->stack;
159                                         }
160                                 }
161
162                                 /*
163                                  * Point to the thread structure that must
164                                  * be freed outside the locks:
165                                  */
166                                 pthread_cln = pthread;
167
168                         } else {
169                                 /*
170                                  * This thread has not detached, so do
171                                  * not destroy it.
172                                  *
173                                  * Check if the stack was not specified by
174                                  * the caller to pthread_create() and has not
175                                  * been destroyed yet: 
176                                  */
177                                 if (pthread->attr.stackaddr_attr == NULL &&
178                                     pthread->stack != NULL) {
179                                         if (pthread->attr.stacksize_attr
180                                             == PTHREAD_STACK_DEFAULT) {
181                                                 /*
182                                                  * Default-size stack.  Cache
183                                                  * it:
184                                                  */
185                                                 struct stack    *spare_stack;
186
187                                                 spare_stack
188                                                     = (pthread->stack
189                                                        + PTHREAD_STACK_DEFAULT
190                                                        - sizeof(struct stack));
191                                                 SLIST_INSERT_HEAD(&_stackq,
192                                                                   spare_stack,
193                                                                   qe);
194                                         } else {
195                                                 /*
196                                                  * Non-standard stack size.
197                                                  * free() it outside the locks:
198                                                  */
199                                                 p_stack = pthread->stack;
200                                         }
201                                         
202                                         /*
203                                          * NULL the stack pointer now
204                                          * that the memory has been freed: 
205                                          */
206                                         pthread->stack = NULL;
207                                 }
208                         }
209                 }
210
211                 /*
212                  * Check if this is not the last thread and there is no
213                  * memory to free this time around.
214                  */
215                 if (!f_done && p_stack == NULL && pthread_cln == NULL) {
216                         /* Get the current time. */
217                         if (clock_gettime(CLOCK_REALTIME,&abstime) != 0)
218                                 PANIC("gc cannot get time");
219
220                         /*
221                          * Do a backup poll in 10 seconds if no threads
222                          * die before then.
223                          */
224                         abstime.tv_sec += 10;
225
226                         /*
227                          * Wait for a signal from a dying thread or a
228                          * timeout (for a backup poll).
229                          */
230                         if ((ret = pthread_cond_timedwait(&_gc_cond,
231                             &_gc_mutex, &abstime)) != 0 && ret != ETIMEDOUT)
232                                 PANIC("gc cannot wait for a signal");
233                 }
234
235                 /* Unlock the garbage collector mutex: */
236                 if (pthread_mutex_unlock(&_gc_mutex) != 0)
237                         PANIC("Cannot unlock gc mutex");
238
239                 /*
240                  * If there is memory to free, do it now. The call to
241                  * free() might block, so this must be done outside the
242                  * locks.
243                  */
244                 if (p_stack != NULL)
245                         free(p_stack);
246                 if (pthread_cln != NULL) {
247                         if (pthread_cln->name != NULL) {
248                                 /* Free the thread name string. */
249                                 free(pthread_cln->name);
250                         }
251                         _rtld_free_tls(pthread_cln->tcb);
252                         /*
253                          * Free the memory allocated for the thread
254                          * structure.
255                          */
256                         free(pthread_cln);
257                 }
258         }
259         return (NULL);
260 }