xref: /illumos-gate/usr/src/cmd/sgs/rtld/common/external.c (revision 8cd45542)
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 2008 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 /*
30  * Implementation of all external interfaces between ld.so.1 and libc.
31  *
32  * This file started as a set of routines that provided synchronization and
33  * locking operations using calls to libthread.  libthread has merged with libc,
34  * and things have gotten a little simpler.  This file continues to establish
35  * and redirect various events within ld.so.1 to interfaces within libc.
36  *
37  * Until libc is loaded and relocated, any external interfaces are captured
38  * locally.  Each link-map list maintains its own set of external vectors, as
39  * each link-map list typically provides its own libc.  Although this per-link-
40  * map list vectoring provides a degree of flexibility, there is a protocol
41  * expected when calling various libc interfaces.
42  *
43  * i.	Any new alternative link-map list should call CI_THRINIT, and then call
44  *	CI_TLS_MODADD to register any TLS for each object of that link-map list
45  *	(this item is labeled i. as auditors can be the first objects loaded,
46  *	and they exist on their own lik-map list).
47  *
48  * ii.	For the primary link-map list, CI_TLS_STATMOD must be called first to
49  *	register any static TLS.  This routine is called regardless of there
50  *	being any TLS, as this routine also establishes the link-map list as the
51  *	primary list and fixes the association of uberdata).  CI_THRINIT should
52  *	then be called.
53  *
54  * iii.	Any objects added to an existing link-map list (primary or alternative)
55  *	should call CI_TLS_MODADD to register any additional TLS.
56  *
57  * These events are established by:
58  *
59  * i.	Typically, libc is loaded as part of the primary dependencies of any
60  *	link-map list (since the Unified Process Model (UPM), libc can't be
61  *	lazily loaded).  To minimize the possibility of loading and registering
62  *	objects, and then tearing them down (because of a relocation error),
63  *	external vectors are established as part of load_completion().  This
64  *	routine is called on completion of any operation that can cause objects
65  *	to be loaded.  This point of control insures the objects have been fully
66  *	analyzed and relocated, and moved to their controlling link-map list.
67  *	The external vectors are established prior to any .inits being fired.
68  *
69  * ii.	Calls to CI_THRINIT, and CI_TLS_MODADD also occur as part of
70  *	load_completion().  CI_THRINIT is only called once for each link-map
71  *	control list.
72  *
73  * iii.	Calls to CI_TLS_STATMOD, and CI_THRINIT occur for the primary link-map
74  *	list in the final stages of setup().
75  *
76  * The interfaces provide by libc can be divided into two families.  The first
77  * family consists of those interfaces that should be called from the link-map
78  * list.  It's possible that these interfaces convey state concerning the
79  * link-map list they are part of:
80  *
81  *	CI_ATEXIT
82  *	CI TLS_MODADD
83  *	CI_TLS_MODREM
84  *	CI_TLS_STATMOD
85  *	CI_THRINIT
86  *
87  * The second family are global in nature, that is, the link-map list from
88  * which they are called provides no state information.  In fact, for
89  * CI_BIND_GUARD, the calling link-map isn't even known.  The link-map can only
90  * be deduced after ld.so.1's global lock has been obtained.  Therefore, the
91  * following interfaces are also maintained as global:
92  *
93  *	CI_LCMESSAGES
94  *	CI_BIND_GUARD
95  *	CI_BIND_CLEAR
96  *	CI_THR_SELF
97  *
98  * Note, it is possible that these global interfaces are obtained from an
99  * alternative link-map list that gets torn down because of a processing
100  * failure (unlikely, because the link-map list components must be analyzed
101  * and relocated prior to load_completion(), but perhaps the tear down is still
102  * a possibility).  Thus the global interfaces may have to be replaced.  Once
103  * the interfaces have been obtained from the primary link-map, they can
104  * remain fixed, as the primary link-map isn't going to go anywhere.
105  *
106  * The last wrinkle in the puzzle is what happens if an alternative link-map
107  * is loaded with no libc dependency?  In this case, the alternative objects
108  * can not call CI_THRINIT, can not be allowed to use TLS, and will not receive
109  * any atexit processing.
110  *
111  * The history of these external interfaces is defined by their version:
112  *
113  * TI_VERSION == 1
114  *	Under this model libthread provided rw_rwlock/rw_unlock, through which
115  *	all rt_mutex_lock/rt_mutex_unlock calls were vectored.
116  *	Under libc/libthread these interfaces provided _sigon/_sigoff (unlike
117  *	lwp/libthread that provided signal blocking via bind_guard/bind_clear).
118  *
119  * TI_VERSION == 2
120  *	Under this model only libthreads bind_guard/bind_clear and thr_self
121  *	interfaces were used.  Both libthreads blocked signals under the
122  *	bind_guard/bind_clear interfaces.   Lower level locking is derived
123  *	from internally bound _lwp_ interfaces.  This removes recursive
124  *	problems encountered when obtaining locking interfaces from libthread.
125  *	The use of mutexes over reader/writer locks also enables the use of
126  *	condition variables for controlling thread concurrency (allows access
127  *	to objects only after their .init has completed).
128  *
129  * NOTE, the TI_VERSION indicated the ti_interface version number, where the
130  * ti_interface was a large vector of functions passed to both libc (to override
131  * the thread stub interfaces) and ld.so.1.  ld.so.1 used only a small subset of
132  * these interfaces.
133  *
134  * CI_VERSION == 1
135  *	Introduced with CI_VERSION & CI_ATEXIT
136  *
137  * CI_VERSION == 2 (Solaris 8 update 2).
138  *	Added support for CI_LCMESSAGES
139  *
140  * CI_VERSION == 3 (Solaris 9).
141  *	Added the following versions to the CI table:
142  *
143  *		CI_BIND_GUARD, CI_BIND_CLEAR, CI_THR_SELF
144  *		CI_TLS_MODADD, CI_TLS_MOD_REMOVE, CI_TLS_STATMOD
145  *
146  *	This version introduced the DT_SUNW_RTLDINFO structure as a mechanism
147  *	to handshake with ld.so.1.
148  *
149  * CI_VERSION == 4 (Solaris 10).
150  *	Added the CI_THRINIT handshake as part of the libc/libthread unified
151  *	process model.  libc now initializes the current thread pointer from
152  *	this interface (and no longer relies on the INITFIRST flag - which
153  *	others have started to camp out on).
154  *
155  * Release summary:
156  *
157  *	Solaris 8	CI_ATEXIT via _ld_libc()
158  *			TI_* via _ld_concurrency()
159  *
160  *	Solaris 9	CI_ATEXIT and CI_LCMESSAGES via _ld_libc()
161  *			CI_* via RTLDINFO and _ld_libc()  - new libthread
162  *			TI_* via _ld_concurrency()  - old libthread
163  *
164  *	Solaris 10	CI_ATEXIT and CI_LCMESSAGES via _ld_libc()
165  *			CI_* via RTLDINFO and _ld_libc()  - new libthread
166  */
167 
168 #include "_synonyms.h"
169 #include <sys/debug.h>
170 #include <synch.h>
171 #include <signal.h>
172 #include <thread.h>
173 #include <synch.h>
174 #include <strings.h>
175 #include <stdio.h>
176 #include <debug.h>
177 #include <libc_int.h>
178 #include "_elf.h"
179 #include "_rtld.h"
180 
181 /*
182  * This interface provides the unified process model communication between
183  * ld.so.1 and libc.  This interface is supplied through RTLDINFO.
184  */
185 void
186 get_lcinterface(Rt_map *lmp, Lc_interface *funcs)
187 {
188 	int		threaded = 0;
189 	int		version;
190 	int		tag;
191 	Lm_list		*lml;
192 	Lc_desc		*lcp;
193 
194 	if ((lmp == 0) || (funcs == 0))
195 		return;
196 
197 	lml = LIST(lmp);
198 	lcp = &lml->lm_lcs[0];
199 
200 	DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
201 
202 	for (tag = funcs->ci_tag; tag; tag = (++funcs)->ci_tag) {
203 		char	*gptr;
204 		char	*lptr = funcs->ci_un.ci_ptr;
205 
206 		DBG_CALL(Dbg_util_lcinterface(lmp, tag, lptr));
207 
208 		if (tag >= CI_MAX)
209 			continue;
210 
211 		/*
212 		 * Maintain all interfaces on a per-link-map basis.  Note, for
213 		 * most interfaces, only the first interface is used for any
214 		 * link-map list.  This prevents accidents with developers who
215 		 * manage to load two different versions of libc.
216 		 */
217 		if ((lcp[tag].lc_lmp) &&
218 		    (tag != CI_LCMESSAGES) && (tag != CI_VERSION)) {
219 			DBG_CALL(Dbg_unused_lcinterface(lmp,
220 			    lcp[tag].lc_lmp, tag));
221 			continue;
222 		}
223 
224 		lcp[tag].lc_un.lc_ptr = lptr;
225 		lcp[tag].lc_lmp = lmp;
226 
227 		gptr = glcs[tag].lc_un.lc_ptr;
228 
229 		/*
230 		 * Process any interfaces that must be maintained on a global
231 		 * basis.
232 		 */
233 		switch (tag) {
234 		case CI_ATEXIT:
235 			break;
236 
237 		case CI_LCMESSAGES:
238 			/*
239 			 * At startup, ld.so.1 can establish a locale from one
240 			 * of the locale family of environment variables (see
241 			 * ld_str_env() and readenv_user()).  During process
242 			 * execution the locale can also be changed by the user.
243 			 * This interface is called from libc should the locale
244 			 * be modified.  Presently, only one global locale is
245 			 * maintained for all link-map lists, and only objects
246 			 * on the primrary link-map may change this locale.
247 			 */
248 			if ((lml->lm_flags & LML_FLG_BASELM) &&
249 			    ((gptr == 0) || (strcmp(gptr, lptr) != 0))) {
250 				/*
251 				 * If we've obtained a message locale (typically
252 				 * supplied via libc's setlocale()), then
253 				 * register the locale for use in dgettext() so
254 				 * as to reestablish the locale for ld.so.1's
255 				 * messages.
256 				 */
257 				if (gptr) {
258 					free((void *)gptr);
259 					rtld_flags |= RT_FL_NEWLOCALE;
260 				}
261 				glcs[tag].lc_un.lc_ptr = strdup(lptr);
262 
263 				/*
264 				 * Clear any cached messages.
265 				 */
266 				err_strs[ERR_NONE] = 0;
267 				err_strs[ERR_WARNING] = 0;
268 				err_strs[ERR_FATAL] = 0;
269 				err_strs[ERR_ELF] = 0;
270 
271 				nosym_str = 0;
272 			}
273 			break;
274 
275 		case CI_BIND_GUARD:
276 		case CI_BIND_CLEAR:
277 		case CI_THR_SELF:
278 			/*
279 			 * If the global vector is unset, or this is the primary
280 			 * link-map, set the global vector.
281 			 */
282 			if ((gptr == 0) || (lml->lm_flags & LML_FLG_BASELM))
283 				glcs[tag].lc_un.lc_ptr = lptr;
284 
285 			/* FALLTHROUGH */
286 
287 		case CI_TLS_MODADD:
288 		case CI_TLS_MODREM:
289 		case CI_TLS_STATMOD:
290 		case CI_THRINIT:
291 			threaded++;
292 			break;
293 
294 		case CI_VERSION:
295 			if ((rtld_flags2 & RT_FL2_RTLDSEEN) == 0) {
296 				rtld_flags2 |= RT_FL2_RTLDSEEN;
297 
298 				version = funcs->ci_un.ci_val;
299 #if defined(CI_V_FIVE)
300 				if (version >= CI_V_FIVE) {
301 					thr_flg_nolock = THR_FLG_NOLOCK;
302 					thr_flg_reenter = THR_FLG_REENTER;
303 				}
304 #endif
305 				if (version >= CI_V_FOUR) {
306 					Listnode	*lnp;
307 					Lm_list		*lml2;
308 
309 					rtld_flags2 |= RT_FL2_UNIFPROC;
310 
311 					/*
312 					 * We might have seen auditor which is
313 					 * not dependent on libc.  Such an
314 					 * auditor's link map list has
315 					 * LML_FLG_HOLDLOCK set.  This lock
316 					 * needs to be dropped.  Refer to
317 					 * audit_setup() in audit.c.
318 					 */
319 					if ((rtld_flags2 & RT_FL2_HASAUDIT) ==
320 					    0)
321 					break;
322 
323 					/*
324 					 * Yes, we did. Take care of them.
325 					 */
326 					for (LIST_TRAVERSE(&dynlm_list, lnp,
327 					    lml2)) {
328 						Rt_map *map =
329 						    (Rt_map *)lml2->lm_head;
330 
331 						if (FLAGS(map) & FLG_RT_AUDIT) {
332 							lml2->lm_flags &=
333 							    ~LML_FLG_HOLDLOCK;
334 						}
335 					}
336 				}
337 			}
338 			break;
339 
340 		default:
341 			break;
342 		}
343 	}
344 
345 	if (threaded == 0)
346 		return;
347 
348 	/*
349 	 * If a version of libc gives us only a subset of the TLS interfaces -
350 	 * it's confused and we discard the whole lot.
351 	 */
352 	if ((lcp[CI_TLS_MODADD].lc_un.lc_func &&
353 	    lcp[CI_TLS_MODREM].lc_un.lc_func &&
354 	    lcp[CI_TLS_STATMOD].lc_un.lc_func) == 0) {
355 		lcp[CI_TLS_MODADD].lc_un.lc_func = 0;
356 		lcp[CI_TLS_MODREM].lc_un.lc_func = 0;
357 		lcp[CI_TLS_STATMOD].lc_un.lc_func = 0;
358 	}
359 
360 	/*
361 	 * Indicate that we're now thread capable, and enable concurrency if
362 	 * requested.
363 	 */
364 	if ((rtld_flags & RT_FL_NOCONCUR) == 0)
365 		rtld_flags |= RT_FL_CONCUR;
366 	if ((lml->lm_flags & LML_FLG_RTLDLM) == 0)
367 		rtld_flags |= RT_FL_THREADS;
368 }
369 
370 /*
371  * At this point we know we have a set of objects that have been fully analyzed
372  * and relocated.  Prior to the next major step of running .init sections (ie.
373  * running user code), retrieve any RTLDINFO interfaces.
374  */
375 int
376 rt_get_extern(Lm_list *lml, Rt_map *lmp)
377 {
378 	if (lml->lm_rti) {
379 		Aliste		idx;
380 		Rti_desc	*rti;
381 
382 		for (ALIST_TRAVERSE(lml->lm_rti, idx, rti))
383 			get_lcinterface(rti->rti_lmp, rti->rti_info);
384 
385 		free(lml->lm_rti);
386 		lml->lm_rti = 0;
387 	}
388 
389 	/*
390 	 * Perform some sanity checks.  If we have TLS requirements we better
391 	 * have the associated external interfaces.
392 	 */
393 	if (lml->lm_tls && (lml->lm_lcs[CI_TLS_STATMOD].lc_un.lc_func == 0)) {
394 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_TLS_NOSUPPORT),
395 		    NAME(lmp));
396 		return (0);
397 	}
398 	return (1);
399 }
400 
401 static int	bindmask = 0;
402 
403 int
404 rt_bind_guard(int flags)
405 {
406 	int	(*fptr)(int);
407 	int	bindflag;
408 
409 	if ((fptr = glcs[CI_BIND_GUARD].lc_un.lc_func) != NULL) {
410 		return ((*fptr)(flags));
411 	} else {
412 		bindflag = (flags & THR_FLG_RTLD);
413 		if ((bindflag & bindmask) == 0) {
414 			bindmask |= bindflag;
415 			return (1);
416 		}
417 		return (0);
418 	}
419 }
420 
421 int
422 rt_bind_clear(int flags)
423 {
424 	int	(*fptr)(int);
425 	int	bindflag;
426 
427 	if ((fptr = glcs[CI_BIND_CLEAR].lc_un.lc_func) != NULL) {
428 		return ((*fptr)(flags));
429 	} else {
430 		bindflag = (flags & THR_FLG_RTLD);
431 		if (bindflag == 0)
432 			return (bindmask);
433 		else {
434 			bindmask &= ~bindflag;
435 			return (0);
436 		}
437 	}
438 }
439 
440 /*
441  * Make sure threads have been initialized.  This interface is called once for
442  * each link-map list.
443  */
444 void
445 rt_thr_init(Lm_list *lml)
446 {
447 	void	(*fptr)(void);
448 
449 	if ((fptr = (void (*)())lml->lm_lcs[CI_THRINIT].lc_un.lc_func) != 0) {
450 		lml->lm_lcs[CI_THRINIT].lc_un.lc_func = 0;
451 		leave((Lm_list *)0, thr_flg_reenter);
452 		(*fptr)();
453 		(void) enter(thr_flg_reenter);
454 	}
455 }
456 
457 thread_t
458 rt_thr_self()
459 {
460 	thread_t	(*fptr)(void);
461 
462 	if ((fptr = (thread_t (*)())glcs[CI_THR_SELF].lc_un.lc_func) != NULL)
463 		return ((*fptr)());
464 
465 	return (1);
466 }
467 
468 int
469 rt_mutex_lock(Rt_lock * mp)
470 {
471 	return (_lwp_mutex_lock((lwp_mutex_t *)mp));
472 }
473 
474 int
475 rt_mutex_unlock(Rt_lock * mp)
476 {
477 	return (_lwp_mutex_unlock((lwp_mutex_t *)mp));
478 }
479 
480 Rt_cond *
481 rt_cond_create()
482 {
483 	return (calloc(1, sizeof (Rt_cond)));
484 }
485 
486 int
487 rt_cond_wait(Rt_cond * cvp, Rt_lock * mp)
488 {
489 	return (_lwp_cond_wait(cvp, (lwp_mutex_t *)mp));
490 }
491 
492 int
493 rt_cond_broadcast(Rt_cond * cvp)
494 {
495 	return (_lwp_cond_broadcast(cvp));
496 }
497 
498 #ifdef	EXPAND_RELATIVE
499 
500 /*
501  * Mutex interfaces to resolve references from any objects extracted from
502  * libc_pic.a.  Note, as ld.so.1 is essentially single threaded these can be
503  * noops.
504  */
505 #pragma weak lmutex_lock = __mutex_lock
506 #pragma weak _private_mutex_lock = __mutex_lock
507 #pragma weak mutex_lock = __mutex_lock
508 #pragma weak _mutex_lock = __mutex_lock
509 /* ARGSUSED */
510 int
511 __mutex_lock(mutex_t *mp)
512 {
513 	return (0);
514 }
515 
516 #pragma weak lmutex_unlock = __mutex_unlock
517 #pragma weak _private_mutex_unlock = __mutex_unlock
518 #pragma weak mutex_unlock = __mutex_unlock
519 #pragma weak _mutex_unlock = __mutex_unlock
520 /* ARGSUSED */
521 int
522 __mutex_unlock(mutex_t *mp)
523 {
524 	return (0);
525 }
526 
527 #pragma weak _private_mutex_init = __mutex_init
528 #pragma weak mutex_init = __mutex_init
529 #pragma weak _mutex_init = __mutex_init
530 /* ARGSUSED */
531 int
532 __mutex_init(mutex_t *mp, int type, void *arg)
533 {
534 	return (0);
535 }
536 
537 #pragma weak _private_mutex_destroy = __mutex_destroy
538 #pragma weak mutex_destroy = __mutex_destroy
539 #pragma weak _mutex_destroy = __mutex_destroy
540 /* ARGSUSED */
541 int
542 __mutex_destroy(mutex_t *mp)
543 {
544 	return (0);
545 }
546 
547 /*
548  * This is needed to satisfy sysconf() (case _SC_THREAD_STACK_MIN)
549  */
550 #pragma weak thr_min_stack = _thr_min_stack
551 size_t
552 _thr_min_stack()
553 {
554 #ifdef _LP64
555 	return (8 * 1024);
556 #else
557 	return (4 * 1024);
558 #endif
559 }
560 
561 /*
562  * The following functions are cancellation points in libc.
563  * They are called from other functions in libc that we extract
564  * and use directly.  We don't do cancellation while we are in
565  * the dynamic linker, so we redefine these to call the primitive,
566  * non-cancellation interfaces.
567  */
568 
569 #pragma weak close = _close
570 int
571 _close(int fildes)
572 {
573 	extern int __close(int);
574 
575 	return (__close(fildes));
576 }
577 
578 #pragma weak fcntl = _fcntl
579 int
580 _fcntl(int fildes, int cmd, ...)
581 {
582 	extern int __fcntl(int, int, ...);
583 	intptr_t arg;
584 	va_list ap;
585 
586 	va_start(ap, cmd);
587 	arg = va_arg(ap, intptr_t);
588 	va_end(ap);
589 	return (__fcntl(fildes, cmd, arg));
590 }
591 
592 #pragma weak open = _open
593 int
594 _open(const char *path, int oflag, ...)
595 {
596 	extern int __open(const char *, int, ...);
597 	mode_t mode;
598 	va_list ap;
599 
600 	va_start(ap, oflag);
601 	mode = va_arg(ap, mode_t);
602 	va_end(ap);
603 	return (__open(path, oflag, mode));
604 }
605 
606 #pragma weak openat = _openat
607 int
608 _openat(int fd, const char *path, int oflag, ...)
609 {
610 	extern int __openat(int, const char *, int, ...);
611 	mode_t mode;
612 	va_list ap;
613 
614 	va_start(ap, oflag);
615 	mode = va_arg(ap, mode_t);
616 	va_end(ap);
617 	return (__openat(fd, path, oflag, mode));
618 }
619 
620 #pragma weak read = _read
621 ssize_t
622 _read(int fd, void *buf, size_t size)
623 {
624 	extern ssize_t __read(int, void *, size_t);
625 	return (__read(fd, buf, size));
626 }
627 
628 #pragma weak write = _write
629 ssize_t
630 _write(int fd, const void *buf, size_t size)
631 {
632 	extern ssize_t __write(int, const void *, size_t);
633 	return (__write(fd, buf, size));
634 }
635 
636 #endif	/* EXPAND_RELATIVE */
637