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