Merge branch 'vendor/GCC50'
[dragonfly.git] / lib / libc / stdlib / atexit.c
1 /*-
2  * Copyright (c) 1990, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Chris Torek.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the University nor the names of its 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 THE REGENTS 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 REGENTS 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  * @(#)atexit.c 8.2 (Berkeley) 7/3/94
33  * $FreeBSD: head/lib/libc/stdlib/atexit.c 211894 2010-08-27 19:57:17Z kib $
34  */
35
36 #include "namespace.h"
37 #include <link.h>
38 #include <stddef.h>
39 #include <stdlib.h>
40 #include <unistd.h>
41 #include <pthread.h>
42 #include "atexit.h"
43 #include "un-namespace.h"
44
45 #include "libc_private.h"
46
47 #define ATEXIT_FN_EMPTY 0
48 #define ATEXIT_FN_STD   1
49 #define ATEXIT_FN_CXA   2
50
51 static pthread_mutex_t atexit_mutex = PTHREAD_MUTEX_INITIALIZER;
52
53 #define _MUTEX_LOCK(x)          if (__isthreaded) _pthread_mutex_lock(x)
54 #define _MUTEX_UNLOCK(x)        if (__isthreaded) _pthread_mutex_unlock(x)
55 #define _MUTEX_DESTROY(x)       if (__isthreaded) _pthread_mutex_destroy(x)
56
57 struct atexit {
58         struct atexit *next;                    /* next in list */
59         int ind;                                /* next index in this table */
60         struct atexit_fn {
61                 int fn_type;                    /* ATEXIT_? from above */
62                 union {
63                         void (*std_func)(void);
64                         void (*cxa_func)(void *);
65                 } fn_ptr;                       /* function pointer */
66                 void *fn_arg;                   /* argument for CXA callback */
67                 void *fn_dso;                   /* shared module handle */
68         } fns[ATEXIT_SIZE];                     /* the table itself */
69 };
70
71 static struct atexit *__atexit;         /* points to head of LIFO stack */
72
73 /*
74  * Register the function described by 'fptr' to be called at application
75  * exit or owning shared object unload time. This is a helper function
76  * for atexit and __cxa_atexit.
77  */
78 static int
79 atexit_register(struct atexit_fn *fptr)
80 {
81         static struct atexit __atexit0; /* one guaranteed table */
82         struct atexit *p;
83
84         _MUTEX_LOCK(&atexit_mutex);
85         if ((p = __atexit) == NULL)
86                 __atexit = p = &__atexit0;
87         else while (p->ind >= ATEXIT_SIZE) {
88                 struct atexit *old__atexit;
89                 old__atexit = __atexit;
90                 _MUTEX_UNLOCK(&atexit_mutex);
91                 if ((p = (struct atexit *)malloc(sizeof(*p))) == NULL)
92                         return (-1);
93                 _MUTEX_LOCK(&atexit_mutex);
94                 if (old__atexit != __atexit) {
95                         /* Lost race, retry operation */
96                         _MUTEX_UNLOCK(&atexit_mutex);
97                         free(p);
98                         _MUTEX_LOCK(&atexit_mutex);
99                         p = __atexit;
100                         continue;
101                 }
102                 p->ind = 0;
103                 p->next = __atexit;
104                 __atexit = p;
105         }
106         p->fns[p->ind++] = *fptr;
107         _MUTEX_UNLOCK(&atexit_mutex);
108         return 0;
109 }
110
111 /*
112  * Register a function to be performed at exit.
113  */
114 int
115 atexit(void (*func)(void))
116 {
117         struct atexit_fn fn;
118         int error;
119
120         fn.fn_type = ATEXIT_FN_STD;
121         fn.fn_ptr.std_func = func;
122         fn.fn_arg = NULL;
123         fn.fn_dso = NULL;
124
125         error = atexit_register(&fn);
126         return (error);
127 }
128
129 /*
130  * Register a function to be performed at exit or when an shared object
131  * with given dso handle is unloaded dynamically.
132  */
133 int
134 __cxa_atexit(void (*func)(void *), void *arg, void *dso)
135 {
136         struct atexit_fn fn;
137         int error;
138
139         fn.fn_type = ATEXIT_FN_CXA;
140         fn.fn_ptr.cxa_func = func;
141         fn.fn_arg = arg;
142         fn.fn_dso = dso;
143
144         error = atexit_register(&fn);
145         return (error);
146 }
147
148 #pragma weak __pthread_cxa_finalize
149 void __pthread_cxa_finalize(const struct dl_phdr_info *);
150
151 /*
152  * Call all handlers registered with __cxa_atexit for the shared
153  * object owning 'dso'.  Note: if 'dso' is NULL, then all remaining
154  * handlers are called.
155  */
156 void
157 __cxa_finalize(void *dso)
158 {
159         struct dl_phdr_info phdr_info;
160         struct atexit *p;
161         struct atexit_fn fn;
162         int n, has_phdr;
163
164         if (dso != NULL)
165                 has_phdr = _rtld_addr_phdr(dso, &phdr_info);
166         else
167                 has_phdr = 0;
168
169         _MUTEX_LOCK(&atexit_mutex);
170         for (p = __atexit; p; p = p->next) {
171                 for (n = p->ind; --n >= 0;) {
172                         if (p->fns[n].fn_type == ATEXIT_FN_EMPTY)
173                                 continue; /* already been called */
174                         fn = p->fns[n];
175                         if (dso != NULL && dso != fn.fn_dso) {
176                                 /* wrong DSO ? */
177                                 if (!has_phdr || !__elf_phdr_match_addr(
178                                     &phdr_info, fn.fn_ptr.cxa_func))
179                                         continue;
180                         }
181                         /*
182                           Mark entry to indicate that this particular handler
183                           has already been called.
184                         */
185                         p->fns[n].fn_type = ATEXIT_FN_EMPTY;
186                         _MUTEX_UNLOCK(&atexit_mutex);
187
188                         /* Call the function of correct type. */
189                         if (fn.fn_type == ATEXIT_FN_CXA)
190                                 fn.fn_ptr.cxa_func(fn.fn_arg);
191                         else if (fn.fn_type == ATEXIT_FN_STD)
192                                 fn.fn_ptr.std_func();
193                         _MUTEX_LOCK(&atexit_mutex);
194                 }
195         }
196         _MUTEX_UNLOCK(&atexit_mutex);
197         if (dso == NULL)
198                 _MUTEX_DESTROY(&atexit_mutex);
199
200         if (has_phdr && &__pthread_cxa_finalize != NULL)
201                 __pthread_cxa_finalize(&phdr_info);
202 }