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