1 /* $NetBSD: atexit.c,v 1.26 2013/08/19 22:14:37 matt Exp $ */ 2 3 /*- 4 * Copyright (c) 2003 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #if defined(LIBC_SCCS) && !defined(lint) 34 __RCSID("$NetBSD: atexit.c,v 1.26 2013/08/19 22:14:37 matt Exp $"); 35 #endif /* LIBC_SCCS and not lint */ 36 37 #include "reentrant.h" 38 39 #include <assert.h> 40 #include <stdlib.h> 41 42 #include "atexit.h" 43 44 struct atexit_handler { 45 struct atexit_handler *ah_next; 46 union { 47 void (*fun_atexit)(void); 48 void (*fun_cxa_atexit)(void *); 49 } ah_fun; 50 #define ah_atexit ah_fun.fun_atexit 51 #define ah_cxa_atexit ah_fun.fun_cxa_atexit 52 53 void *ah_arg; /* argument for cxa_atexit handlers */ 54 void *ah_dso; /* home DSO for cxa_atexit handlers */ 55 }; 56 57 /* 58 * There must be at least 32 to guarantee ANSI conformance, plus 59 * 3 additional ones for the benefit of the startup code, which 60 * may use them to register the dynamic loader's cleanup routine, 61 * the profiling cleanup routine, and the global destructor routine. 62 */ 63 #define NSTATIC_HANDLERS (32 + 3) 64 static struct atexit_handler atexit_handler0[NSTATIC_HANDLERS]; 65 66 #define STATIC_HANDLER_P(ah) \ 67 (ah >= &atexit_handler0[0] && ah < &atexit_handler0[NSTATIC_HANDLERS]) 68 69 /* 70 * Stack of atexit handlers. Handlers must be called in the opposite 71 * order they were registered. 72 */ 73 static struct atexit_handler *atexit_handler_stack; 74 75 #ifdef _REENTRANT 76 /* ..and a mutex to protect it all. */ 77 mutex_t __atexit_mutex; 78 #endif /* _REENTRANT */ 79 80 void __libc_atexit_init(void) __attribute__ ((visibility("hidden"))); 81 82 /* 83 * Allocate an atexit handler descriptor. If "dso" is NULL, it indicates 84 * a normal atexit handler, which must be allocated from the static pool, 85 * if possible. cxa_atexit handlers are never allocated from the static 86 * pool. 87 * 88 * __atexit_mutex must be held. 89 */ 90 static struct atexit_handler * 91 atexit_handler_alloc(void *dso) 92 { 93 struct atexit_handler *ah; 94 int i; 95 96 if (dso == NULL) { 97 for (i = 0; i < NSTATIC_HANDLERS; i++) { 98 ah = &atexit_handler0[i]; 99 if (ah->ah_atexit == NULL && ah->ah_next == NULL) { 100 /* Slot is free. */ 101 return (ah); 102 } 103 } 104 } 105 106 /* 107 * Either no static slot was free, or this is a cxa_atexit 108 * handler. Allocate a new one. We keep the __atexit_mutex 109 * held to prevent handlers from being run while we (potentially) 110 * block in malloc(). 111 */ 112 ah = malloc(sizeof(*ah)); 113 return (ah); 114 } 115 116 /* 117 * Initialize __atexit_mutex with the PTHREAD_MUTEX_RECURSIVE attribute. 118 * Note that __cxa_finalize may generate calls to __cxa_atexit. 119 */ 120 void __section(".text.startup") 121 __libc_atexit_init(void) 122 { 123 #ifdef _REENTRANT /* !__minix */ 124 mutexattr_t atexit_mutex_attr; 125 mutexattr_init(&atexit_mutex_attr); 126 mutexattr_settype(&atexit_mutex_attr, PTHREAD_MUTEX_RECURSIVE); 127 mutex_init(&__atexit_mutex, &atexit_mutex_attr); 128 #endif /* _REENTRANT */ 129 } 130 131 /* 132 * Register an atexit routine. This is suitable either for a cxa_atexit 133 * or normal atexit type handler. The __cxa_atexit() name and arguments 134 * are specified by the C++ ABI. See: 135 * 136 * http://www.codesourcery.com/cxx-abi/abi.html#dso-dtor 137 */ 138 int 139 __cxa_atexit(void (*func)(void *), void *arg, void *dso) 140 { 141 struct atexit_handler *ah; 142 143 _DIAGASSERT(func != NULL); 144 145 mutex_lock(&__atexit_mutex); 146 147 ah = atexit_handler_alloc(dso); 148 if (ah == NULL) { 149 mutex_unlock(&__atexit_mutex); 150 return (-1); 151 } 152 153 ah->ah_cxa_atexit = func; 154 ah->ah_arg = arg; 155 ah->ah_dso = dso; 156 157 ah->ah_next = atexit_handler_stack; 158 atexit_handler_stack = ah; 159 160 mutex_unlock(&__atexit_mutex); 161 return (0); 162 } 163 164 /* 165 * Run the list of atexit handlers. If dso is NULL, run all of them, 166 * otherwise run only those matching the specified dso. 167 * 168 * Note that we can be recursively invoked; rtld cleanup is via an 169 * atexit handler, and rtld cleanup invokes _fini() for DSOs, which 170 * in turn invokes __cxa_finalize() for the DSO. 171 */ 172 void 173 __cxa_finalize(void *dso) 174 { 175 static u_int call_depth; 176 struct atexit_handler *ah, *dead_handlers = NULL, **prevp; 177 void (*cxa_func)(void *); 178 void (*atexit_func)(void); 179 180 mutex_lock(&__atexit_mutex); 181 call_depth++; 182 183 /* 184 * If we are at call depth 1 (which is usually the "do everything" 185 * call from exit(3)), we go ahead and remove elements from the 186 * list as we call them. This will prevent any nested calls from 187 * having to traverse elements we've already processed. If we are 188 * at call depth > 1, we simply mark elements we process as unused. 189 * When the depth 1 caller sees those, it will simply unlink them 190 * for us. 191 */ 192 again: 193 for (prevp = &atexit_handler_stack; (ah = (*prevp)) != NULL;) { 194 if (dso == NULL || dso == ah->ah_dso || ah->ah_atexit == NULL) { 195 if (ah->ah_atexit != NULL) { 196 void *p = atexit_handler_stack; 197 if (ah->ah_dso != NULL) { 198 cxa_func = ah->ah_cxa_atexit; 199 ah->ah_cxa_atexit = NULL; 200 (*cxa_func)(ah->ah_arg); 201 } else { 202 atexit_func = ah->ah_atexit; 203 ah->ah_atexit = NULL; 204 (*atexit_func)(); 205 } 206 /* Restart if new atexit handler was added. */ 207 if (p != atexit_handler_stack) 208 goto again; 209 } 210 211 if (call_depth == 1) { 212 *prevp = ah->ah_next; 213 if (STATIC_HANDLER_P(ah)) 214 ah->ah_next = NULL; 215 else { 216 ah->ah_next = dead_handlers; 217 dead_handlers = ah; 218 } 219 } else 220 prevp = &ah->ah_next; 221 } else 222 prevp = &ah->ah_next; 223 } 224 call_depth--; 225 mutex_unlock(&__atexit_mutex); 226 227 if (call_depth > 0) 228 return; 229 230 /* 231 * Now free any dead handlers. Do this even if we're about to 232 * exit, in case a leak-detecting malloc is being used. 233 */ 234 while ((ah = dead_handlers) != NULL) { 235 dead_handlers = ah->ah_next; 236 free(ah); 237 } 238 } 239 240 /* 241 * Register a function to be performed at exit. 242 */ 243 int 244 atexit(void (*func)(void)) 245 { 246 247 return (__cxa_atexit((void (*)(void *))func, NULL, NULL)); 248 } 249