lib/libc/stdlib/atexit.c

   1 /*      $NetBSD: atexit.c,v 1.24 2009/10/08 16:33:45 pooka 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.24 2009/10/08 16:33:45 pooka 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 static 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
 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 }