lib/libc/stdlib/atexit.c

   1 /*      $NetBSD: atexit.c,v 1.29 2015/04/19 18:15:26 joerg 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.29 2015/04/19 18:15:26 joerg 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
 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
 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 #if defined(__ARM_EABI__) && !defined(lint)
 139 int
 140 __aeabi_atexit(void *arg, void (*func)(void *), void *dso);
 141
 142 int
 143 __aeabi_atexit(void *arg, void (*func)(void *), void *dso)
 144 {
 145         return __cxa_atexit(func, arg, dso);
 146 }
 147 #endif
 148
 149 int
 150 __cxa_atexit(void (*func)(void *), void *arg, void *dso)
 151 {
 152         struct atexit_handler *ah;
 153
 154         _DIAGASSERT(func != NULL);
 155
 156         mutex_lock(&__atexit_mutex);
 157
 158         ah = atexit_handler_alloc(dso);
 159         if (ah == NULL) {
 160                 mutex_unlock(&__atexit_mutex);
 161                 return (-1);
 162         }
 163
 164         ah->ah_cxa_atexit = func;
 165         ah->ah_arg = arg;
 166         ah->ah_dso = dso;
 167
 168         ah->ah_next = atexit_handler_stack;
 169         atexit_handler_stack = ah;
 170
 171         mutex_unlock(&__atexit_mutex);
 172         return (0);
 173 }
 174
 175 /*
 176  * Run the list of atexit handlers.  If dso is NULL, run all of them,
 177  * otherwise run only those matching the specified dso.
 178  *
 179  * Note that we can be recursively invoked; rtld cleanup is via an
 180  * atexit handler, and rtld cleanup invokes _fini() for DSOs, which
 181  * in turn invokes __cxa_finalize() for the DSO.
 182  */
 183 void
 184 __cxa_finalize(void *dso)
 185 {
 186         static u_int call_depth;
 187         struct atexit_handler *ah, *dead_handlers = NULL, **prevp;
 188         void (*cxa_func)(void *);
 189         void (*atexit_func)(void);
 190
 191         mutex_lock(&__atexit_mutex);
 192         call_depth++;
 193
 194         /*
 195          * If we are at call depth 1 (which is usually the "do everything"
 196          * call from exit(3)), we go ahead and remove elements from the
 197          * list as we call them.  This will prevent any nested calls from
 198          * having to traverse elements we've already processed.  If we are
 199          * at call depth > 1, we simply mark elements we process as unused.
 200          * When the depth 1 caller sees those, it will simply unlink them
 201          * for us.
 202          */
 203 again:
 204         for (prevp = &atexit_handler_stack; (ah = (*prevp)) != NULL;) {
 205                 if (dso == NULL || dso == ah->ah_dso || ah->ah_atexit == NULL) {
 206                         if (ah->ah_atexit != NULL) {
 207                                 void *p = atexit_handler_stack;
 208                                 if (ah->ah_dso != NULL) {
 209                                         cxa_func = ah->ah_cxa_atexit;
 210                                         ah->ah_cxa_atexit = NULL;
 211                                         (*cxa_func)(ah->ah_arg);
 212                                 } else {
 213                                         atexit_func = ah->ah_atexit;
 214                                         ah->ah_atexit = NULL;
 215                                         (*atexit_func)();
 216                                 }
 217                                 /* Restart if new atexit handler was added. */
 218                                 if (p != atexit_handler_stack)
 219                                         goto again;
 220                         }
 221
 222                         if (call_depth == 1) {
 223                                 *prevp = ah->ah_next;
 224                                 if (STATIC_HANDLER_P(ah))
 225                                         ah->ah_next = NULL;
 226                                 else {
 227                                         ah->ah_next = dead_handlers;
 228                                         dead_handlers = ah;
 229                                 }
 230                         } else
 231                                 prevp = &ah->ah_next;
 232                 } else
 233                         prevp = &ah->ah_next;
 234         }
 235         call_depth--;
 236         mutex_unlock(&__atexit_mutex);
 237
 238         if (call_depth > 0)
 239                 return;
 240
 241         /*
 242          * Now free any dead handlers.  Do this even if we're about to
 243          * exit, in case a leak-detecting malloc is being used.
 244          */
 245         while ((ah = dead_handlers) != NULL) {
 246                 dead_handlers = ah->ah_next;
 247                 free(ah);
 248         }
 249 }
 250
 251 /*
 252  * Register a function to be performed at exit.
 253  */
 254 int
 255 atexit(void (*func)(void))
 256 {
 257
 258         return (__cxa_atexit((void (*)(void *))func, NULL, NULL));
 259 }