1/* Copyright (C) 1991-2021 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 <https://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"
26DEFINE_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. */
31bool __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. */
36void
37attribute_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
136void
137exit (int status)
138{
139 __run_exit_handlers (status, &__exit_funcs, true, true);
140}
141libc_hidden_def (exit)
142