1/*-
2 * Copyright (c) 1990, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Chris Torek.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 *    may be used to endorse or promote products derived from this software
18 *    without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33#if defined(LIBC_SCCS) && !defined(lint)
34static char sccsid[] = "@(#)atexit.c	8.2 (Berkeley) 7/3/94";
35#endif /* LIBC_SCCS and not lint */
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD: stable/11/lib/libc/stdlib/atexit.c 346538 2019-04-22 10:02:34Z kib $");
38
39#include "namespace.h"
40#include <errno.h>
41#include <link.h>
42#include <stddef.h>
43#include <stdlib.h>
44#include <unistd.h>
45#include <pthread.h>
46#include "atexit.h"
47#include "un-namespace.h"
48#include "block_abi.h"
49
50#include "libc_private.h"
51
52/**
53 * The _Block_copy() function is provided by the block runtime.
54 */
55__attribute__((weak)) void*
56_Block_copy(void*);
57
58#define	ATEXIT_FN_EMPTY	0
59#define	ATEXIT_FN_STD	1
60#define	ATEXIT_FN_CXA	2
61
62static pthread_mutex_t atexit_mutex = PTHREAD_MUTEX_INITIALIZER;
63
64#define _MUTEX_LOCK(x)		if (__isthreaded) _pthread_mutex_lock(x)
65#define _MUTEX_UNLOCK(x)	if (__isthreaded) _pthread_mutex_unlock(x)
66#define _MUTEX_DESTROY(x)	if (__isthreaded) _pthread_mutex_destroy(x)
67
68struct atexit {
69	struct atexit *next;			/* next in list */
70	int ind;				/* next index in this table */
71	struct atexit_fn {
72		int fn_type;			/* ATEXIT_? from above */
73		union {
74			void (*std_func)(void);
75			void (*cxa_func)(void *);
76		} fn_ptr;			/* function pointer */
77		void *fn_arg;			/* argument for CXA callback */
78		void *fn_dso;			/* shared module handle */
79	} fns[ATEXIT_SIZE];			/* the table itself */
80};
81
82static struct atexit *__atexit;		/* points to head of LIFO stack */
83typedef DECLARE_BLOCK(void, atexit_block, void);
84
85int atexit_b(atexit_block);
86int __cxa_atexit(void (*)(void *), void *, void *);
87
88/*
89 * Register the function described by 'fptr' to be called at application
90 * exit or owning shared object unload time. This is a helper function
91 * for atexit and __cxa_atexit.
92 */
93static int
94atexit_register(struct atexit_fn *fptr)
95{
96	static struct atexit __atexit0;	/* one guaranteed table */
97	struct atexit *p;
98
99	_MUTEX_LOCK(&atexit_mutex);
100	if ((p = __atexit) == NULL)
101		__atexit = p = &__atexit0;
102	else while (p->ind >= ATEXIT_SIZE) {
103		struct atexit *old__atexit;
104		old__atexit = __atexit;
105	        _MUTEX_UNLOCK(&atexit_mutex);
106		if ((p = (struct atexit *)malloc(sizeof(*p))) == NULL)
107			return (-1);
108		_MUTEX_LOCK(&atexit_mutex);
109		if (old__atexit != __atexit) {
110			/* Lost race, retry operation */
111			_MUTEX_UNLOCK(&atexit_mutex);
112			free(p);
113			_MUTEX_LOCK(&atexit_mutex);
114			p = __atexit;
115			continue;
116		}
117		p->ind = 0;
118		p->next = __atexit;
119		__atexit = p;
120	}
121	p->fns[p->ind++] = *fptr;
122	_MUTEX_UNLOCK(&atexit_mutex);
123	return 0;
124}
125
126/*
127 * Register a function to be performed at exit.
128 */
129int
130atexit(void (*func)(void))
131{
132	struct atexit_fn fn;
133	int error;
134
135	fn.fn_type = ATEXIT_FN_STD;
136	fn.fn_ptr.std_func = func;
137	fn.fn_arg = NULL;
138	fn.fn_dso = NULL;
139
140	error = atexit_register(&fn);
141	return (error);
142}
143__weak_reference(atexit, __libc_atexit);
144
145/**
146 * Register a block to be performed at exit.
147 */
148int
149atexit_b(atexit_block func)
150{
151	struct atexit_fn fn;
152	int error;
153	if (_Block_copy == 0) {
154		errno = ENOSYS;
155		return -1;
156	}
157	func = _Block_copy(func);
158
159	// Blocks are not C++ destructors, but they have the same signature (a
160	// single void* parameter), so we can pretend that they are.
161	fn.fn_type = ATEXIT_FN_CXA;
162	fn.fn_ptr.cxa_func = (void(*)(void*))GET_BLOCK_FUNCTION(func);
163	fn.fn_arg = func;
164	fn.fn_dso = NULL;
165
166	error = atexit_register(&fn);
167	return (error);
168}
169
170/*
171 * Register a function to be performed at exit or when an shared object
172 * with given dso handle is unloaded dynamically.
173 */
174int
175__cxa_atexit(void (*func)(void *), void *arg, void *dso)
176{
177	struct atexit_fn fn;
178	int error;
179
180	fn.fn_type = ATEXIT_FN_CXA;
181	fn.fn_ptr.cxa_func = func;
182	fn.fn_arg = arg;
183	fn.fn_dso = dso;
184
185	error = atexit_register(&fn);
186	return (error);
187}
188
189#pragma weak __pthread_cxa_finalize
190void __pthread_cxa_finalize(const struct dl_phdr_info *);
191
192static int global_exit;
193
194/*
195 * Call all handlers registered with __cxa_atexit for the shared
196 * object owning 'dso'.  Note: if 'dso' is NULL, then all remaining
197 * handlers are called.
198 */
199void
200__cxa_finalize(void *dso)
201{
202	struct dl_phdr_info phdr_info;
203	struct atexit *p;
204	struct atexit_fn fn;
205	int n, has_phdr;
206
207	if (dso != NULL) {
208		has_phdr = _rtld_addr_phdr(dso, &phdr_info);
209	} else {
210		has_phdr = 0;
211		global_exit = 1;
212	}
213
214	_MUTEX_LOCK(&atexit_mutex);
215	for (p = __atexit; p; p = p->next) {
216		for (n = p->ind; --n >= 0;) {
217			if (p->fns[n].fn_type == ATEXIT_FN_EMPTY)
218				continue; /* already been called */
219			fn = p->fns[n];
220			if (dso != NULL && dso != fn.fn_dso) {
221				/* wrong DSO ? */
222				if (!has_phdr || global_exit ||
223				    !__elf_phdr_match_addr(&phdr_info,
224				    fn.fn_ptr.cxa_func))
225					continue;
226			}
227			/*
228			  Mark entry to indicate that this particular handler
229			  has already been called.
230			*/
231			p->fns[n].fn_type = ATEXIT_FN_EMPTY;
232		        _MUTEX_UNLOCK(&atexit_mutex);
233
234			/* Call the function of correct type. */
235			if (fn.fn_type == ATEXIT_FN_CXA)
236				fn.fn_ptr.cxa_func(fn.fn_arg);
237			else if (fn.fn_type == ATEXIT_FN_STD)
238				fn.fn_ptr.std_func();
239			_MUTEX_LOCK(&atexit_mutex);
240		}
241	}
242	_MUTEX_UNLOCK(&atexit_mutex);
243	if (dso == NULL)
244		_MUTEX_DESTROY(&atexit_mutex);
245
246	if (has_phdr && !global_exit && &__pthread_cxa_finalize != NULL)
247		__pthread_cxa_finalize(&phdr_info);
248}
249