stdlib/exit.c

   1 /* Copyright (C) 1991-2019 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21 #include <sysdep.h>
  22 #include <libc-lock.h>
  23 #include "exit.h"
  24
  25 #include "set-hooks.h"
  26 DEFINE_HOOK (__libc_atexit, (void))
  27
  28 /* Initialize the flag that indicates exit function processing
  29    is complete. See concurrency notes in stdlib/exit.h where
  30    __exit_funcs_lock is declared.  */
  31 bool __exit_funcs_done = false;
  32
  33 /* Call all functions registered with `atexit' and `on_exit',
  34    in the reverse of the order in which they were registered
  35    perform stdio cleanup, and terminate program execution with STATUS.  */
  36 void
  37 attribute_hidden
  38 __run_exit_handlers (int status, struct exit_function_list **listp,
  39                      bool run_list_atexit, bool run_dtors)
  40 {
  41   /* First, call the TLS destructors.  */
  42 #ifndef SHARED
  43   if (&__call_tls_dtors != NULL)
  44 #endif
  45     if (run_dtors)
  46       __call_tls_dtors ();
  47
  48   /* We do it this way to handle recursive calls to exit () made by
  49      the functions registered with `atexit' and `on_exit'. We call
  50      everyone on the list and use the status value in the last
  51      exit (). */
  52   while (true)
  53     {
  54       struct exit_function_list *cur;
  55
  56       __libc_lock_lock (__exit_funcs_lock);
  57
  58     restart:
  59       cur = *listp;
  60
  61       if (cur == NULL)
  62         {
  63           /* Exit processing complete.  We will not allow any more
  64              atexit/on_exit registrations.  */
  65           __exit_funcs_done = true;
  66           __libc_lock_unlock (__exit_funcs_lock);
  67           break;
  68         }
  69
  70       while (cur->idx > 0)
  71         {
  72           struct exit_function *const f = &cur->fns[--cur->idx];
  73           const uint64_t new_exitfn_called = __new_exitfn_called;
  74
  75           /* Unlock the list while we call a foreign function.  */
  76           __libc_lock_unlock (__exit_funcs_lock);
  77           switch (f->flavor)
  78             {
  79               void (*atfct) (void);
  80               void (*onfct) (int status, void *arg);
  81               void (*cxafct) (void *arg, int status);
  82
  83             case ef_free:
  84             case ef_us:
  85               break;
  86             case ef_on:
  87               onfct = f->func.on.fn;
  88 #ifdef PTR_DEMANGLE
  89               PTR_DEMANGLE (onfct);
  90 #endif
  91               onfct (status, f->func.on.arg);
  92               break;
  93             case ef_at:
  94               atfct = f->func.at;
  95 #ifdef PTR_DEMANGLE
  96               PTR_DEMANGLE (atfct);
  97 #endif
  98               atfct ();
  99               break;
 100             case ef_cxa:
 101               /* To avoid dlclose/exit race calling cxafct twice (BZ 22180),
 102                  we must mark this function as ef_free.  */
 103               f->flavor = ef_free;
 104               cxafct = f->func.cxa.fn;
 105 #ifdef PTR_DEMANGLE
 106               PTR_DEMANGLE (cxafct);
 107 #endif
 108               cxafct (f->func.cxa.arg, status);
 109               break;
 110             }
 111           /* Re-lock again before looking at global state.  */
 112           __libc_lock_lock (__exit_funcs_lock);
 113
 114           if (__glibc_unlikely (new_exitfn_called != __new_exitfn_called))
 115             /* The last exit function, or another thread, has registered
 116                more exit functions.  Start the loop over.  */
 117             goto restart;
 118         }
 119
 120       *listp = cur->next;
 121       if (*listp != NULL)
 122         /* Don't free the last element in the chain, this is the statically
 123            allocate element.  */
 124         free (cur);
 125
 126       __libc_lock_unlock (__exit_funcs_lock);
 127     }
 128
 129   if (run_list_atexit)
 130     RUN_HOOK (__libc_atexit, ());
 131
 132   _exit (status);
 133 }
 134
 135
 136 void
 137 exit (int status)
 138 {
 139   __run_exit_handlers (status, &__exit_funcs, true, true);
 140 }
 141 libc_hidden_def (exit)