xref: /titanic_44/usr/src/lib/libc/port/gen/atexit.c (revision e5ba14ff435beeefdaa2e6649e175c74afe02c76)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*	Copyright (c) 1988 AT&T	*/
30 /*	  All Rights Reserved  	*/
31 
32 #pragma weak atexit = _atexit
33 
34 #include "synonyms.h"
35 #include "thr_uberdata.h"
36 #include "libc_int.h"
37 #include "atexit.h"
38 #include "stdiom.h"
39 
40 /*
41  * Note that memory is managed by lmalloc()/lfree().
42  *
43  * Among other reasons, this is occasioned by the insistence of our
44  * brothers sh(1) and csh(1) that they can do malloc, etc., better than
45  * libc can.  Those programs define their own malloc routines, and
46  * initialize the underlying mechanism in main().  This means that calls
47  * to malloc occuring before main will crash.  The loader calls atexit(3C)
48  * before calling main, so we'd better avoid malloc() when it does.
49  *
50  * Another reason for using lmalloc()/lfree() is that the atexit()
51  * list must transcend all link maps.  See the Linker and Libraries
52  * Guide for information on alternate link maps.
53  *
54  * See "thr_uberdata.h" for the definitions of structures used here.
55  */
56 
57 static int in_range(_exithdlr_func_t, Lc_addr_range_t[], uint_t count);
58 
59 extern	caddr_t	_getfp(void);
60 
61 /*
62  * exitfns_lock is declared to be a recursive mutex so that we
63  * can hold it while calling out to the registered functions.
64  * If they call back to us, we are self-consistent and everything
65  * works, even the case of calling exit() from functions called
66  * by _exithandle() (recursive exit()).  All that is required is
67  * that the registered functions actually return (no longjmp()s).
68  *
69  * Because exitfns_lock is declared to be a recursive mutex, we
70  * cannot use it with lmutex_lock()/lmutex_unlock() and we must use
71  * rmutex_lock()/rmutex_unlock() (which are defined to be simply
72  * mutex_lock()/mutex_unlock()).  This means that atexit() and
73  * exit() are not async-signal-safe.  We make them fork1-safe
74  * via the atexit_locks()/atexit_unlocks() functions, called from
75  * libc_prepare_atfork()/libc_child_atfork()/libc_parent_atfork()
76  */
77 
78 /*
79  * atexit_locks() and atexit_unlocks() are called on every link map.
80  * Do not use curthread->ul_uberdata->atexit_root for these.
81  */
82 void
83 atexit_locks()
84 {
85 	(void) rmutex_lock(&__uberdata.atexit_root.exitfns_lock);
86 }
87 
88 void
89 atexit_unlocks()
90 {
91 	(void) rmutex_unlock(&__uberdata.atexit_root.exitfns_lock);
92 }
93 
94 /*
95  * atexit() is called before the primordial thread is fully set up.
96  * Be careful about dereferencing self->ul_uberdata->atexit_root.
97  */
98 int
99 _atexit(void (*func)(void))
100 {
101 	ulwp_t *self;
102 	atexit_root_t *arp;
103 	_exthdlr_t *p;
104 
105 	if ((p = lmalloc(sizeof (_exthdlr_t))) == NULL)
106 		return (-1);
107 
108 	if ((self = __curthread()) == NULL)
109 		arp = &__uberdata.atexit_root;
110 	else {
111 		arp = &self->ul_uberdata->atexit_root;
112 		(void) rmutex_lock(&arp->exitfns_lock);
113 	}
114 	p->hdlr = func;
115 	p->next = arp->head;
116 	arp->head = p;
117 	if (self != NULL)
118 		(void) rmutex_unlock(&arp->exitfns_lock);
119 	return (0);
120 }
121 
122 void
123 _exithandle(void)
124 {
125 	atexit_root_t *arp = &curthread->ul_uberdata->atexit_root;
126 	_exthdlr_t *p;
127 
128 	(void) rmutex_lock(&arp->exitfns_lock);
129 	arp->exit_frame_monitor = _getfp() + STACK_BIAS;
130 	p = arp->head;
131 	while (p != NULL) {
132 		arp->head = p->next;
133 		p->hdlr();
134 		lfree(p, sizeof (_exthdlr_t));
135 		p = arp->head;
136 	}
137 	(void) rmutex_unlock(&arp->exitfns_lock);
138 }
139 
140 /*
141  * _get_exit_frame_monitor is called by the C++ runtimes.
142  */
143 void *
144 _get_exit_frame_monitor(void)
145 {
146 	atexit_root_t *arp = &curthread->ul_uberdata->atexit_root;
147 	return (&arp->exit_frame_monitor);
148 }
149 
150 /*
151  * The following is a routine which the loader (ld.so.1) calls when it
152  * processes a dlclose call on an object.  It resets all signal handlers
153  * which fall within the union of the ranges specified by the elements
154  * of the array range to SIG_DFL.
155  */
156 static void
157 _preexec_sig_unload(Lc_addr_range_t range[], uint_t count)
158 {
159 	uberdata_t *udp = curthread->ul_uberdata;
160 	int sig;
161 	rwlock_t *rwlp;
162 	struct sigaction *sap;
163 	struct sigaction oact;
164 	void (*handler)();
165 
166 	for (sig = 1; sig < NSIG; sig++) {
167 		sap = (struct sigaction *)&udp->siguaction[sig].sig_uaction;
168 again:
169 		handler = sap->sa_handler;
170 		if (handler != SIG_DFL && handler != SIG_IGN &&
171 		    in_range(handler, range, count)) {
172 			rwlp = &udp->siguaction[sig].sig_lock;
173 			lrw_wrlock(rwlp);
174 			if (handler != sap->sa_handler) {
175 				lrw_unlock(rwlp);
176 				goto again;
177 			}
178 			sap->sa_handler = SIG_DFL;
179 			sap->sa_flags = SA_SIGINFO;
180 			(void) sigemptyset(&sap->sa_mask);
181 			if (__sigaction(sig, NULL, &oact) == 0 &&
182 			    oact.sa_handler != SIG_DFL &&
183 			    oact.sa_handler != SIG_IGN)
184 				(void) __sigaction(sig, sap, NULL);
185 			lrw_unlock(rwlp);
186 		}
187 	}
188 }
189 
190 /*
191  * The following is a routine which the loader (ld.so.1) calls when it
192  * processes a dlclose call on an object.  It cancels all atfork() entries
193  * whose prefork, parent postfork, or child postfork functions fall within
194  * the union of the ranges specified by the elements of the array range.
195  */
196 static void
197 _preexec_atfork_unload(Lc_addr_range_t range[], uint_t count)
198 {
199 	ulwp_t *self = curthread;
200 	uberdata_t *udp = self->ul_uberdata;
201 	atfork_t *atfork_q;
202 	atfork_t *atfp;
203 	atfork_t *next;
204 	void (*func)(void);
205 	int start_again;
206 
207 	(void) _private_mutex_lock(&udp->atfork_lock);
208 	if ((atfork_q = udp->atforklist) != NULL) {
209 		atfp = atfork_q;
210 		do {
211 			next = atfp->forw;
212 			start_again = 0;
213 
214 			if (((func = atfp->prepare) != NULL &&
215 			    in_range(func, range, count)) ||
216 			    ((func = atfp->parent) != NULL &&
217 			    in_range(func, range, count)) ||
218 			    ((func = atfp->child) != NULL &&
219 			    in_range(func, range, count))) {
220 				if (self->ul_fork) {
221 					/*
222 					 * dlclose() called from a fork handler.
223 					 * Deleting the entry would wreak havoc.
224 					 * Just null out the function pointers
225 					 * and leave the entry in place.
226 					 */
227 					atfp->prepare = NULL;
228 					atfp->parent = NULL;
229 					atfp->child = NULL;
230 					continue;
231 				}
232 				if (atfp == atfork_q) {
233 					/* deleting the list head member */
234 					udp->atforklist = atfork_q = next;
235 					start_again = 1;
236 				}
237 				atfp->forw->back = atfp->back;
238 				atfp->back->forw = atfp->forw;
239 				lfree(atfp, sizeof (atfork_t));
240 				if (atfp == atfork_q) {
241 					/* we deleted the whole list */
242 					udp->atforklist = NULL;
243 					break;
244 				}
245 			}
246 		} while ((atfp = next) != atfork_q || start_again);
247 	}
248 	(void) _private_mutex_unlock(&udp->atfork_lock);
249 }
250 
251 /*
252  * The following is a routine which the loader (ld.so.1) calls when it
253  * processes a dlclose call on an object.  It sets the destructor
254  * function pointer to NULL for all keys whose destructors fall within
255  * the union of the ranges specified by the elements of the array range.
256  * We don't assign TSD_UNALLOCATED (the equivalent of pthread_key_destroy())
257  * because the thread may use the key's TSD further on in fini processing.
258  */
259 static void
260 _preexec_tsd_unload(Lc_addr_range_t range[], uint_t count)
261 {
262 	tsd_metadata_t *tsdm = &curthread->ul_uberdata->tsd_metadata;
263 	void (*func)(void *);
264 	int key;
265 
266 	lmutex_lock(&tsdm->tsdm_lock);
267 	for (key = 1; key < tsdm->tsdm_nused; key++) {
268 		if ((func = tsdm->tsdm_destro[key]) != NULL &&
269 		    func != TSD_UNALLOCATED &&
270 		    in_range((_exithdlr_func_t)func, range, count))
271 			tsdm->tsdm_destro[key] = NULL;
272 	}
273 	lmutex_unlock(&tsdm->tsdm_lock);
274 }
275 
276 /*
277  * The following is a routine which the loader (ld.so.1) calls when it
278  * processes dlclose calls on objects with atexit registrations.  It
279  * executes the exit handlers that fall within the union of the ranges
280  * specified by the elements of the array range in the REVERSE ORDER of
281  * their registration.  Do not change this characteristic; it is REQUIRED
282  * BEHAVIOR.
283  */
284 int
285 _preexec_exit_handlers(Lc_addr_range_t range[], uint_t count)
286 {
287 	atexit_root_t *arp = &curthread->ul_uberdata->atexit_root;
288 	_exthdlr_t *o;		/* previous node */
289 	_exthdlr_t *p;		/* this node */
290 
291 	(void) rmutex_lock(&arp->exitfns_lock);
292 	o = NULL;
293 	p = arp->head;
294 	while (p != NULL) {
295 		if (in_range(p->hdlr, range, count)) {
296 			/* We need to execute this one */
297 			if (o != NULL)
298 				o->next = p->next;
299 			else
300 				arp->head = p->next;
301 			p->hdlr();
302 			lfree(p, sizeof (_exthdlr_t));
303 			o = NULL;
304 			p = arp->head;
305 		} else {
306 			o = p;
307 			p = p->next;
308 		}
309 	}
310 	(void) rmutex_unlock(&arp->exitfns_lock);
311 
312 	_preexec_tsd_unload(range, count);
313 	_preexec_atfork_unload(range, count);
314 	_preexec_sig_unload(range, count);
315 
316 	return (0);
317 }
318 
319 static int
320 in_range(_exithdlr_func_t addr, Lc_addr_range_t ranges[], uint_t count)
321 {
322 	uint_t idx;
323 
324 	for (idx = 0; idx < count; idx++) {
325 		if ((void *)addr >= ranges[idx].lb &&
326 		    (void *)addr < ranges[idx].ub) {
327 			return (1);
328 		}
329 	}
330 
331 	return (0);
332 }
333