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 mutexattr_t atexit_mutex_attr; 124 mutexattr_init(&atexit_mutex_attr); 125 mutexattr_settype(&atexit_mutex_attr, PTHREAD_MUTEX_RECURSIVE); 126 mutex_init(&__atexit_mutex, &atexit_mutex_attr); 127 } 128 129 /* 130 * Register an atexit routine. This is suitable either for a cxa_atexit 131 * or normal atexit type handler. The __cxa_atexit() name and arguments 132 * are specified by the C++ ABI. See: 133 * 134 * http://www.codesourcery.com/cxx-abi/abi.html#dso-dtor 135 */ 136 int 137 __cxa_atexit(void (*func)(void *), void *arg, void *dso) 138 { 139 struct atexit_handler *ah; 140 141 _DIAGASSERT(func != NULL); 142 143 mutex_lock(&__atexit_mutex); 144 145 ah = atexit_handler_alloc(dso); 146 if (ah == NULL) { 147 mutex_unlock(&__atexit_mutex); 148 return (-1); 149 } 150 151 ah->ah_cxa_atexit = func; 152 ah->ah_arg = arg; 153 ah->ah_dso = dso; 154 155 ah->ah_next = atexit_handler_stack; 156 atexit_handler_stack = ah; 157 158 mutex_unlock(&__atexit_mutex); 159 return (0); 160 } 161 162 /* 163 * Run the list of atexit handlers. If dso is NULL, run all of them, 164 * otherwise run only those matching the specified dso. 165 * 166 * Note that we can be recursively invoked; rtld cleanup is via an 167 * atexit handler, and rtld cleanup invokes _fini() for DSOs, which 168 * in turn invokes __cxa_finalize() for the DSO. 169 */ 170 void 171 __cxa_finalize(void *dso) 172 { 173 static u_int call_depth; 174 struct atexit_handler *ah, *dead_handlers = NULL, **prevp; 175 void (*cxa_func)(void *); 176 void (*atexit_func)(void); 177 178 mutex_lock(&__atexit_mutex); 179 call_depth++; 180 181 /* 182 * If we are at call depth 1 (which is usually the "do everything" 183 * call from exit(3)), we go ahead and remove elements from the 184 * list as we call them. This will prevent any nested calls from 185 * having to traverse elements we've already processed. If we are 186 * at call depth > 1, we simply mark elements we process as unused. 187 * When the depth 1 caller sees those, it will simply unlink them 188 * for us. 189 */ 190 again: 191 for (prevp = &atexit_handler_stack; (ah = (*prevp)) != NULL;) { 192 if (dso == NULL || dso == ah->ah_dso || ah->ah_atexit == NULL) { 193 if (ah->ah_atexit != NULL) { 194 void *p = atexit_handler_stack; 195 if (ah->ah_dso != NULL) { 196 cxa_func = ah->ah_cxa_atexit; 197 ah->ah_cxa_atexit = NULL; 198 (*cxa_func)(ah->ah_arg); 199 } else { 200 atexit_func = ah->ah_atexit; 201 ah->ah_atexit = NULL; 202 (*atexit_func)(); 203 } 204 /* Restart if new atexit handler was added. */ 205 if (p != atexit_handler_stack) 206 goto again; 207 } 208 209 if (call_depth == 1) { 210 *prevp = ah->ah_next; 211 if (STATIC_HANDLER_P(ah)) 212 ah->ah_next = NULL; 213 else { 214 ah->ah_next = dead_handlers; 215 dead_handlers = ah; 216 } 217 } else 218 prevp = &ah->ah_next; 219 } else 220 prevp = &ah->ah_next; 221 } 222 call_depth--; 223 mutex_unlock(&__atexit_mutex); 224 225 if (call_depth > 0) 226 return; 227 228 /* 229 * Now free any dead handlers. Do this even if we're about to 230 * exit, in case a leak-detecting malloc is being used. 231 */ 232 while ((ah = dead_handlers) != NULL) { 233 dead_handlers = ah->ah_next; 234 free(ah); 235 } 236 } 237 238 /* 239 * Register a function to be performed at exit. 240 */ 241 int 242 atexit(void (*func)(void)) 243 { 244 245 return (__cxa_atexit((void (*)(void *))func, NULL, NULL)); 246 } 247