libc/stdlib/atexit.c

   1 /* Copyright (C) 1995,1996 Robert de Bath <rdebath@cix.compulink.co.uk>
   2  * This file is part of the Linux-8086 C library and is distributed
   3  * under the GNU Library General Public License.
   4  */
   5
   6 /*
   7  * Dec 2000          Manuel Novoa III
   8  *
   9  *   Made atexit handling conform to standards... i.e. no args.
  10  *   Removed on_exit since it did not match gnu libc definition.
  11  *   Combined atexit and __do_exit into one object file.
  12  *
  13  * Feb 2001          Manuel Novoa III
  14  *
  15  *   Reworked file after addition of __uClibc_main.
  16  *   Changed name of __do_exit to atexit_handler.
  17  *   Changed name of __cleanup to __uClibc_cleanup.
  18  *   Moved declaration of __uClibc_cleanup to __uClibc_main
  19  *      where it is initialized with (possibly weak alias)
  20  *      _stdio_term.
  21  *
  22  * Jul 2001          Steve Thayer
  23  *
  24  *   Added an on_exit implementation (that now matches gnu libc definition.)
  25  *   Pulled atexit_handler out of the atexit object since it is now required by
  26  *   on_exit as well.  Renamed it to __exit_handler.
  27  *   Fixed a problem where exit functions stop getting called if one of
  28  *   them calls exit().
  29  *   As a side effect of these changes, abort() no longer calls the exit
  30  *   functions (it now matches the gnu libc definition).
  31  *
  32  * August 2002    Erik Andersen
  33  *   Added locking so atexit and friends can be thread safe
  34  *
  35  * August 2005    Stephen Warren
  36  *   Added __cxa_atexit and __cxa_finalize support
  37  *
  38  */
  39
  40 #include <features.h>
  41 #include <unistd.h>
  42 #include <stdlib.h>
  43 #include <errno.h>
  44 #include <atomic.h>
  45
  46 libc_hidden_proto(exit)
  47 libc_hidden_proto(_exit)
  48
  49 #ifdef __UCLIBC_HAS_THREADS__
  50 # include <pthread.h>
  51 extern pthread_mutex_t mylock;
  52 #endif
  53 #define LOCK    __pthread_mutex_lock(&mylock)
  54 #define UNLOCK  __pthread_mutex_unlock(&mylock)
  55
  56
  57 typedef void (*aefuncp) (void);         /* atexit function pointer */
  58 typedef void (*oefuncp) (int, void *);  /* on_exit function pointer */
  59 typedef void (*cxaefuncp) (void *);     /* __cxa_atexit function pointer */
  60 typedef enum {
  61     ef_free,
  62     ef_in_use,
  63     ef_on_exit,
  64     ef_cxa_atexit
  65 } ef_type; /* exit function types */
  66
  67 /* this is in the L_exit object */
  68 extern void (*__exit_cleanup) (int) attribute_hidden;
  69
  70 /* these are in the L___do_exit object */
  71 extern int __exit_slots attribute_hidden;
  72 extern int __exit_count attribute_hidden;
  73 extern void __exit_handler(int) attribute_hidden;
  74 struct exit_function {
  75         /*
  76          * 'type' should be of type of the 'enum ef_type' above but since we
  77          * need this element in an atomic operation we have to use 'long int'.
  78          */
  79         long int type; /* enum ef_type */
  80         union {
  81                 struct {
  82                         oefuncp func;
  83                         void *arg;
  84                 } on_exit;
  85                 struct {
  86                         cxaefuncp func;
  87                         void *arg;
  88                         void* dso_handle;
  89                 } cxa_atexit;
  90         } funcs;
  91 };
  92 #ifdef __UCLIBC_DYNAMIC_ATEXIT__
  93 extern struct exit_function *__exit_function_table attribute_hidden;
  94 #else
  95 extern struct exit_function __exit_function_table[__UCLIBC_MAX_ATEXIT] attribute_hidden;
  96 #endif
  97 extern struct exit_function *__new_exitfn (void) attribute_hidden;
  98
  99 /* this is in the L___cxa_atexit object */
 100 extern int __cxa_atexit (cxaefuncp, void *arg, void *dso_handle);
 101
 102
 103 /* remove old_atexit after 0.9.29 */
 104 #if defined(L_atexit) || defined(L_old_atexit)
 105 extern void *__dso_handle __attribute__ ((__weak__));
 106
 107 /*
 108  * register a function to be called at normal program termination
 109  * (the registered function takes no arguments)
 110  */
 111 #ifdef L_atexit
 112 int attribute_hidden atexit(aefuncp func)
 113 #else
 114 int old_atexit(aefuncp func)
 115 #endif
 116 {
 117     /*
 118      * glibc casts aefuncp to cxaefuncp.
 119      * This seems dodgy, but I guess callling a function with more
 120      * parameters than it needs will work everywhere?
 121      */
 122     return __cxa_atexit((cxaefuncp)func, NULL,
 123                         &__dso_handle == NULL ? NULL : __dso_handle);
 124 }
 125 #ifndef L_atexit
 126 weak_alias(old_atexit,atexit)
 127 #endif
 128 #endif
 129
 130 #ifdef L_on_exit
 131 /*
 132  * register a function to be called at normal program termination
 133  * the registered function takes two arguments:
 134  *     status - the exit status that was passed to the exit() function
 135  *     arg - generic argument
 136  */
 137 int on_exit(oefuncp func, void *arg)
 138 {
 139     struct exit_function *efp;
 140
 141     if (func == NULL) {
 142         return 0;
 143     }
 144
 145     efp = __new_exitfn();
 146     if (efp == NULL) {
 147         return -1;
 148     }
 149
 150     efp->funcs.on_exit.func = func;
 151     efp->funcs.on_exit.arg = arg;
 152     /* assign last for thread safety, since we're now unlocked */
 153     efp->type = ef_on_exit;
 154
 155     return 0;
 156 }
 157 #endif
 158
 159 #ifdef L___cxa_atexit
 160 libc_hidden_proto(__cxa_atexit)
 161 int __cxa_atexit (cxaefuncp func, void *arg, void *dso_handle)
 162 {
 163     struct exit_function *efp;
 164
 165     if (func == NULL) {
 166         return 0;
 167     }
 168
 169     efp = __new_exitfn();
 170     if (efp == NULL) {
 171         return -1;
 172     }
 173
 174     efp->funcs.cxa_atexit.func = func;
 175     efp->funcs.cxa_atexit.arg = arg;
 176     efp->funcs.cxa_atexit.dso_handle = dso_handle;
 177     /* assign last for thread safety, since we're now unlocked */
 178     efp->type = ef_cxa_atexit;
 179
 180     return 0;
 181 }
 182 libc_hidden_def(__cxa_atexit)
 183 #endif
 184
 185 #ifdef L___cxa_finalize
 186 /*
 187  * If D is non-NULL, call all functions registered with `__cxa_atexit'
 188  *  with the same dso handle.  Otherwise, if D is NULL, call all of the
 189  *  registered handlers.
 190  */
 191 void __cxa_finalize (void *dso_handle);
 192 void __cxa_finalize (void *dso_handle)
 193 {
 194     struct exit_function *efp;
 195     int exit_count_snapshot = __exit_count;
 196
 197     /* In reverse order */
 198     while (exit_count_snapshot) {
 199         efp = &__exit_function_table[--exit_count_snapshot];
 200
 201         /*
 202          * We check dso_handle match before we verify the type of the union entry.
 203          * However, the atomic_exchange will validate that we were really "allowed"
 204          * to read dso_handle...
 205          */
 206         if ((dso_handle == NULL || dso_handle == efp->funcs.cxa_atexit.dso_handle)
 207             /* We don't want to run this cleanup more than once. */
 208             && !atomic_compare_and_exchange_bool_acq(&efp->type, ef_free, ef_cxa_atexit)
 209            ) {
 210             /* glibc passes status (0) too, but that's not in the prototype */
 211             (*efp->funcs.cxa_atexit.func)(efp->funcs.cxa_atexit.arg);
 212         }
 213     }
 214
 215 #if 0 /* haven't looked into this yet... */
 216     /*
 217      * Remove the registered fork handlers. We do not have to
 218      * unregister anything if the program is going to terminate anyway.
 219      */
 220 #ifdef UNREGISTER_ATFORK
 221     if (d != NULL) {
 222         UNREGISTER_ATFORK (d);
 223     }
 224 #endif
 225 #endif
 226 }
 227 #endif
 228
 229 #ifdef L___exit_handler
 230 int __exit_count = 0; /* Number of registered exit functions */
 231 #ifdef __UCLIBC_DYNAMIC_ATEXIT__
 232 struct exit_function *__exit_function_table = NULL;
 233 int __exit_slots = 0; /* Size of __exit_function_table */
 234 #else
 235 struct exit_function __exit_function_table[__UCLIBC_MAX_ATEXIT];
 236 #endif
 237
 238 /*
 239  * Find and return a new exit_function pointer, for atexit,
 240  * onexit and __cxa_atexit to initialize
 241  */
 242 struct exit_function attribute_hidden *__new_exitfn(void)
 243 {
 244     struct exit_function *efp;
 245
 246     LOCK;
 247
 248 #ifdef __UCLIBC_DYNAMIC_ATEXIT__
 249     /* If we are out of function table slots, make some more */
 250     if (__exit_slots < __exit_count+1) {
 251         efp=realloc(__exit_function_table,
 252                     (__exit_slots+20)*sizeof(struct exit_function));
 253         if (efp == NULL) {
 254             UNLOCK;
 255             __set_errno(ENOMEM);
 256             return 0;
 257         }
 258         __exit_function_table = efp;
 259         __exit_slots += 20;
 260     }
 261 #else
 262     if (__exit_count >= __UCLIBC_MAX_ATEXIT) {
 263         UNLOCK;
 264         __set_errno(ENOMEM);
 265         return 0;
 266     }
 267 #endif
 268
 269     __exit_cleanup = __exit_handler; /* enable cleanup */
 270     efp = &__exit_function_table[__exit_count++];
 271     efp->type = ef_in_use;
 272
 273     UNLOCK;
 274
 275     return efp;
 276 }
 277
 278 /*
 279  * Handle the work of executing the registered exit functions
 280  * This is called while we are locked, so no additional locking
 281  * is needed...
 282  */
 283 void __exit_handler(int status)
 284 {
 285         struct exit_function *efp;
 286
 287         /* In reverse order */
 288         while ( __exit_count ) {
 289                 efp = &__exit_function_table[--__exit_count];
 290                 switch (efp->type) {
 291                 case ef_on_exit:
 292                         if (efp->funcs.on_exit.func) {
 293                                 (efp->funcs.on_exit.func) (status, efp->funcs.on_exit.arg);
 294                         }
 295                         break;
 296                 case ef_cxa_atexit:
 297                         if (efp->funcs.cxa_atexit.func) {
 298                                 /* glibc passes status too, but that's not in the prototype */
 299                                 (efp->funcs.cxa_atexit.func) (efp->funcs.cxa_atexit.arg);
 300                         }
 301                         break;
 302                 }
 303         }
 304 #ifdef __UCLIBC_DYNAMIC_ATEXIT__
 305         /* Free up memory used by the __exit_function_table structure */
 306         if (__exit_function_table)
 307             free(__exit_function_table);
 308 #endif
 309 }
 310 #endif
 311
 312 #ifdef L_exit
 313 extern void weak_function _stdio_term(void) attribute_hidden;
 314 attribute_hidden void (*__exit_cleanup) (int) = 0;
 315 #ifdef __UCLIBC_HAS_THREADS__
 316 pthread_mutex_t mylock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 317 #endif
 318
 319 #ifdef __UCLIBC_CTOR_DTOR__
 320 extern void (*__app_fini)(void);
 321 #endif
 322
 323 extern void (*__rtld_fini)(void);
 324
 325 /*
 326  * Normal program termination
 327  */
 328 void exit(int rv)
 329 {
 330         /* Perform exit-specific cleanup (atexit and on_exit) */
 331         LOCK;
 332         if (__exit_cleanup) {
 333                 __exit_cleanup(rv);
 334         }
 335         UNLOCK;
 336
 337 #ifdef __UCLIBC_CTOR_DTOR__
 338         if (__app_fini != NULL)
 339                 (__app_fini)();
 340 #endif
 341         if (__rtld_fini != NULL)
 342                 (__rtld_fini)();
 343
 344     /* If we are using stdio, try to shut it down.  At the very least,
 345          * this will attempt to commit all buffered writes.  It may also
 346          * unbuffer all writable files, or close them outright.
 347          * Check the stdio routines for details. */
 348         if (_stdio_term)
 349             _stdio_term();
 350
 351         _exit(rv);
 352 }
 353 libc_hidden_def(exit)
 354 #endif