110a4fa49Srie /* 210a4fa49Srie * CDDL HEADER START 310a4fa49Srie * 410a4fa49Srie * The contents of this file are subject to the terms of the 510a4fa49Srie * Common Development and Distribution License (the "License"). 610a4fa49Srie * You may not use this file except in compliance with the License. 710a4fa49Srie * 810a4fa49Srie * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 910a4fa49Srie * or http://www.opensolaris.org/os/licensing. 1010a4fa49Srie * See the License for the specific language governing permissions 1110a4fa49Srie * and limitations under the License. 1210a4fa49Srie * 1310a4fa49Srie * When distributing Covered Code, include this CDDL HEADER in each 1410a4fa49Srie * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 1510a4fa49Srie * If applicable, add the following below this CDDL HEADER, with the 1610a4fa49Srie * fields enclosed by brackets "[]" replaced with your own identifying 1710a4fa49Srie * information: Portions Copyright [yyyy] [name of copyright owner] 1810a4fa49Srie * 1910a4fa49Srie * CDDL HEADER END 2010a4fa49Srie */ 2110a4fa49Srie 2210a4fa49Srie /* 232020b2b6SRod Evans * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved. 2410a4fa49Srie */ 25a574db85Sraf 2610a4fa49Srie /* 2710a4fa49Srie * Implementation of all external interfaces between ld.so.1 and libc. 2810a4fa49Srie * 2910a4fa49Srie * This file started as a set of routines that provided synchronization and 3043d7826aSRod Evans * locking operations using calls to libthread. libthread has merged with libc 3143d7826aSRod Evans * under the Unified Process Model (UPM), and things have gotten a lot simpler. 3243d7826aSRod Evans * This file continues to establish and redirect various events within ld.so.1 3343d7826aSRod Evans * to interfaces within libc. 3410a4fa49Srie * 3510a4fa49Srie * Until libc is loaded and relocated, any external interfaces are captured 3610a4fa49Srie * locally. Each link-map list maintains its own set of external vectors, as 3710a4fa49Srie * each link-map list typically provides its own libc. Although this per-link- 3810a4fa49Srie * map list vectoring provides a degree of flexibility, there is a protocol 3910a4fa49Srie * expected when calling various libc interfaces. 4010a4fa49Srie * 4110a4fa49Srie * i. Any new alternative link-map list should call CI_THRINIT, and then call 4210a4fa49Srie * CI_TLS_MODADD to register any TLS for each object of that link-map list 4310a4fa49Srie * (this item is labeled i. as auditors can be the first objects loaded, 4410a4fa49Srie * and they exist on their own lik-map list). 4510a4fa49Srie * 4610a4fa49Srie * ii. For the primary link-map list, CI_TLS_STATMOD must be called first to 4710a4fa49Srie * register any static TLS. This routine is called regardless of there 4810a4fa49Srie * being any TLS, as this routine also establishes the link-map list as the 4910a4fa49Srie * primary list and fixes the association of uberdata). CI_THRINIT should 5010a4fa49Srie * then be called. 5110a4fa49Srie * 5210a4fa49Srie * iii. Any objects added to an existing link-map list (primary or alternative) 5310a4fa49Srie * should call CI_TLS_MODADD to register any additional TLS. 5410a4fa49Srie * 5510a4fa49Srie * These events are established by: 5610a4fa49Srie * 5710a4fa49Srie * i. Typically, libc is loaded as part of the primary dependencies of any 5810a4fa49Srie * link-map list (since the Unified Process Model (UPM), libc can't be 5910a4fa49Srie * lazily loaded). To minimize the possibility of loading and registering 6010a4fa49Srie * objects, and then tearing them down (because of a relocation error), 6110a4fa49Srie * external vectors are established as part of load_completion(). This 6210a4fa49Srie * routine is called on completion of any operation that can cause objects 6310a4fa49Srie * to be loaded. This point of control insures the objects have been fully 6410a4fa49Srie * analyzed and relocated, and moved to their controlling link-map list. 6510a4fa49Srie * The external vectors are established prior to any .inits being fired. 6610a4fa49Srie * 6710a4fa49Srie * ii. Calls to CI_THRINIT, and CI_TLS_MODADD also occur as part of 6810a4fa49Srie * load_completion(). CI_THRINIT is only called once for each link-map 6910a4fa49Srie * control list. 7010a4fa49Srie * 7110a4fa49Srie * iii. Calls to CI_TLS_STATMOD, and CI_THRINIT occur for the primary link-map 7210a4fa49Srie * list in the final stages of setup(). 7310a4fa49Srie * 7410a4fa49Srie * The interfaces provide by libc can be divided into two families. The first 7510a4fa49Srie * family consists of those interfaces that should be called from the link-map 7610a4fa49Srie * list. It's possible that these interfaces convey state concerning the 7710a4fa49Srie * link-map list they are part of: 7810a4fa49Srie * 7910a4fa49Srie * CI_ATEXIT 8010a4fa49Srie * CI TLS_MODADD 8110a4fa49Srie * CI_TLS_MODREM 8210a4fa49Srie * CI_TLS_STATMOD 8310a4fa49Srie * CI_THRINIT 8410a4fa49Srie * 8510a4fa49Srie * The second family are global in nature, that is, the link-map list from 8610a4fa49Srie * which they are called provides no state information. In fact, for 8710a4fa49Srie * CI_BIND_GUARD, the calling link-map isn't even known. The link-map can only 8810a4fa49Srie * be deduced after ld.so.1's global lock has been obtained. Therefore, the 8910a4fa49Srie * following interfaces are also maintained as global: 9010a4fa49Srie * 9110a4fa49Srie * CI_LCMESSAGES 9210a4fa49Srie * CI_BIND_GUARD 9310a4fa49Srie * CI_BIND_CLEAR 9410a4fa49Srie * CI_THR_SELF 9510a4fa49Srie * 9610a4fa49Srie * Note, it is possible that these global interfaces are obtained from an 9710a4fa49Srie * alternative link-map list that gets torn down because of a processing 9810a4fa49Srie * failure (unlikely, because the link-map list components must be analyzed 9910a4fa49Srie * and relocated prior to load_completion(), but perhaps the tear down is still 10010a4fa49Srie * a possibility). Thus the global interfaces may have to be replaced. Once 10110a4fa49Srie * the interfaces have been obtained from the primary link-map, they can 10210a4fa49Srie * remain fixed, as the primary link-map isn't going to go anywhere. 10310a4fa49Srie * 10410a4fa49Srie * The last wrinkle in the puzzle is what happens if an alternative link-map 10510a4fa49Srie * is loaded with no libc dependency? In this case, the alternative objects 10610a4fa49Srie * can not call CI_THRINIT, can not be allowed to use TLS, and will not receive 10710a4fa49Srie * any atexit processing. 10810a4fa49Srie * 10910a4fa49Srie * The history of these external interfaces is defined by their version: 11010a4fa49Srie * 11110a4fa49Srie * TI_VERSION == 1 11210a4fa49Srie * Under this model libthread provided rw_rwlock/rw_unlock, through which 11310a4fa49Srie * all rt_mutex_lock/rt_mutex_unlock calls were vectored. 11410a4fa49Srie * Under libc/libthread these interfaces provided _sigon/_sigoff (unlike 11510a4fa49Srie * lwp/libthread that provided signal blocking via bind_guard/bind_clear). 11610a4fa49Srie * 11710a4fa49Srie * TI_VERSION == 2 11810a4fa49Srie * Under this model only libthreads bind_guard/bind_clear and thr_self 11910a4fa49Srie * interfaces were used. Both libthreads blocked signals under the 12010a4fa49Srie * bind_guard/bind_clear interfaces. Lower level locking is derived 12110a4fa49Srie * from internally bound _lwp_ interfaces. This removes recursive 12210a4fa49Srie * problems encountered when obtaining locking interfaces from libthread. 12310a4fa49Srie * The use of mutexes over reader/writer locks also enables the use of 12410a4fa49Srie * condition variables for controlling thread concurrency (allows access 12510a4fa49Srie * to objects only after their .init has completed). 12610a4fa49Srie * 12710a4fa49Srie * NOTE, the TI_VERSION indicated the ti_interface version number, where the 12810a4fa49Srie * ti_interface was a large vector of functions passed to both libc (to override 12910a4fa49Srie * the thread stub interfaces) and ld.so.1. ld.so.1 used only a small subset of 13010a4fa49Srie * these interfaces. 13110a4fa49Srie * 13210a4fa49Srie * CI_VERSION == 1 13310a4fa49Srie * Introduced with CI_VERSION & CI_ATEXIT 13410a4fa49Srie * 13510a4fa49Srie * CI_VERSION == 2 (Solaris 8 update 2). 13610a4fa49Srie * Added support for CI_LCMESSAGES 13710a4fa49Srie * 13810a4fa49Srie * CI_VERSION == 3 (Solaris 9). 13910a4fa49Srie * Added the following versions to the CI table: 14010a4fa49Srie * 14110a4fa49Srie * CI_BIND_GUARD, CI_BIND_CLEAR, CI_THR_SELF 14210a4fa49Srie * CI_TLS_MODADD, CI_TLS_MOD_REMOVE, CI_TLS_STATMOD 14310a4fa49Srie * 14410a4fa49Srie * This version introduced the DT_SUNW_RTLDINFO structure as a mechanism 14510a4fa49Srie * to handshake with ld.so.1. 14610a4fa49Srie * 14710a4fa49Srie * CI_VERSION == 4 (Solaris 10). 14810a4fa49Srie * Added the CI_THRINIT handshake as part of the libc/libthread unified 14910a4fa49Srie * process model. libc now initializes the current thread pointer from 15010a4fa49Srie * this interface (and no longer relies on the INITFIRST flag - which 15110a4fa49Srie * others have started to camp out on). 15210a4fa49Srie * 1532a8d6ebaSRod Evans * CI_VERSION == 5 (Solaris 11). 1542a8d6ebaSRod Evans * Use of "protected" references within libc, so that symbols are 1552a8d6ebaSRod Evans * pre-bound, and don't require ld.so.1 binding. This implementation 1562a8d6ebaSRod Evans * protects libc's critical regions from being vectored to auditors. 1572a8d6ebaSRod Evans * 1582a8d6ebaSRod Evans * CI_VERSION == 6 (Solaris 11). 1592a8d6ebaSRod Evans * Added the CI_CRITICAL handshake, to allow "mem*" family to be reexposed 1602a8d6ebaSRod Evans * as "global", and thus be redirected to auxiliary filters. 1612a8d6ebaSRod Evans * 16210a4fa49Srie * Release summary: 16310a4fa49Srie * 16410a4fa49Srie * Solaris 8 CI_ATEXIT via _ld_libc() 16510a4fa49Srie * TI_* via _ld_concurrency() 16610a4fa49Srie * 16710a4fa49Srie * Solaris 9 CI_ATEXIT and CI_LCMESSAGES via _ld_libc() 16810a4fa49Srie * CI_* via RTLDINFO and _ld_libc() - new libthread 16910a4fa49Srie * TI_* via _ld_concurrency() - old libthread 17010a4fa49Srie * 17110a4fa49Srie * Solaris 10 CI_ATEXIT and CI_LCMESSAGES via _ld_libc() 17210a4fa49Srie * CI_* via RTLDINFO and _ld_libc() - new libthread 17310a4fa49Srie */ 174a574db85Sraf 175a574db85Sraf #include <sys/debug.h> 176a574db85Sraf #include <synch.h> 177a574db85Sraf #include <signal.h> 178a574db85Sraf #include <thread.h> 179a574db85Sraf #include <synch.h> 180a574db85Sraf #include <strings.h> 181a574db85Sraf #include <stdio.h> 182a574db85Sraf #include <debug.h> 183a574db85Sraf #include <libc_int.h> 184a574db85Sraf #include "_elf.h" 185a574db85Sraf #include "_rtld.h" 18610a4fa49Srie 18710a4fa49Srie /* 18810a4fa49Srie * This interface provides the unified process model communication between 18943d7826aSRod Evans * ld.so.1 and libc. This interface can be called a number of times: 19043d7826aSRod Evans * 19143d7826aSRod Evans * - Initially, this interface is called to process RTLDINFO. This data 19243d7826aSRod Evans * structure is typically provided by libc, and contains the address of 19343d7826aSRod Evans * libc interfaces that must be called to initialize threads information. 19443d7826aSRod Evans * 19543d7826aSRod Evans * - _ld_libc(), this interface can also be called by libc at process 19643d7826aSRod Evans * initialization, after libc has been loaded and relocated, but before 19743d7826aSRod Evans * control has been passed to any user code (.init's or main()). This 19843d7826aSRod Evans * call provides additional libc interface information that ld.so.1 must 19943d7826aSRod Evans * call during process execution. 20043d7826aSRod Evans * 20143d7826aSRod Evans * - _ld_libc() can also be called by libc during process execution to 20243d7826aSRod Evans * re-establish interfaces such as the locale. 20310a4fa49Srie */ 20443d7826aSRod Evans static void 20510a4fa49Srie get_lcinterface(Rt_map *lmp, Lc_interface *funcs) 20610a4fa49Srie { 20743d7826aSRod Evans int threaded = 0, entry = 0, tag; 20810a4fa49Srie Lm_list *lml; 20910a4fa49Srie Lc_desc *lcp; 21010a4fa49Srie 21143d7826aSRod Evans if ((lmp == NULL) || (funcs == NULL)) 21210a4fa49Srie return; 21310a4fa49Srie 21443d7826aSRod Evans /* 21543d7826aSRod Evans * Once the process is active, ensure we grab a lock. 21643d7826aSRod Evans */ 21743d7826aSRod Evans if (rtld_flags & RT_FL_APPLIC) 21843d7826aSRod Evans entry = enter(0); 21943d7826aSRod Evans 22010a4fa49Srie lml = LIST(lmp); 22110a4fa49Srie lcp = &lml->lm_lcs[0]; 22210a4fa49Srie 22310a4fa49Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 22410a4fa49Srie 22510a4fa49Srie for (tag = funcs->ci_tag; tag; tag = (++funcs)->ci_tag) { 22610a4fa49Srie char *gptr; 22710a4fa49Srie char *lptr = funcs->ci_un.ci_ptr; 22810a4fa49Srie 22910a4fa49Srie DBG_CALL(Dbg_util_lcinterface(lmp, tag, lptr)); 23010a4fa49Srie 23110a4fa49Srie if (tag >= CI_MAX) 23210a4fa49Srie continue; 23310a4fa49Srie 23410a4fa49Srie /* 23510a4fa49Srie * Maintain all interfaces on a per-link-map basis. Note, for 23610a4fa49Srie * most interfaces, only the first interface is used for any 23710a4fa49Srie * link-map list. This prevents accidents with developers who 23810a4fa49Srie * manage to load two different versions of libc. 23910a4fa49Srie */ 24010a4fa49Srie if ((lcp[tag].lc_lmp) && 24110a4fa49Srie (tag != CI_LCMESSAGES) && (tag != CI_VERSION)) { 24210a4fa49Srie DBG_CALL(Dbg_unused_lcinterface(lmp, 24310a4fa49Srie lcp[tag].lc_lmp, tag)); 24410a4fa49Srie continue; 24510a4fa49Srie } 24610a4fa49Srie 24710a4fa49Srie lcp[tag].lc_un.lc_ptr = lptr; 24810a4fa49Srie lcp[tag].lc_lmp = lmp; 24910a4fa49Srie 25010a4fa49Srie gptr = glcs[tag].lc_un.lc_ptr; 25110a4fa49Srie 25210a4fa49Srie /* 25310a4fa49Srie * Process any interfaces that must be maintained on a global 25410a4fa49Srie * basis. 25510a4fa49Srie */ 25610a4fa49Srie switch (tag) { 25710a4fa49Srie case CI_ATEXIT: 25810a4fa49Srie break; 25910a4fa49Srie 26010a4fa49Srie case CI_LCMESSAGES: 26110a4fa49Srie /* 26210a4fa49Srie * At startup, ld.so.1 can establish a locale from one 26310a4fa49Srie * of the locale family of environment variables (see 26410a4fa49Srie * ld_str_env() and readenv_user()). During process 26510a4fa49Srie * execution the locale can also be changed by the user. 26610a4fa49Srie * This interface is called from libc should the locale 26710a4fa49Srie * be modified. Presently, only one global locale is 26810a4fa49Srie * maintained for all link-map lists, and only objects 26910a4fa49Srie * on the primrary link-map may change this locale. 27010a4fa49Srie */ 27110a4fa49Srie if ((lml->lm_flags & LML_FLG_BASELM) && 27243d7826aSRod Evans ((gptr == NULL) || (strcmp(gptr, lptr) != 0))) { 27310a4fa49Srie /* 27410a4fa49Srie * If we've obtained a message locale (typically 27510a4fa49Srie * supplied via libc's setlocale()), then 27610a4fa49Srie * register the locale for use in dgettext() so 27710a4fa49Srie * as to reestablish the locale for ld.so.1's 27810a4fa49Srie * messages. 27910a4fa49Srie */ 28010a4fa49Srie if (gptr) { 28110a4fa49Srie free((void *)gptr); 28210a4fa49Srie rtld_flags |= RT_FL_NEWLOCALE; 28310a4fa49Srie } 28410a4fa49Srie glcs[tag].lc_un.lc_ptr = strdup(lptr); 28510a4fa49Srie 28610a4fa49Srie /* 28710a4fa49Srie * Clear any cached messages. 28810a4fa49Srie */ 28943d7826aSRod Evans bzero(err_strs, sizeof (err_strs)); 29043d7826aSRod Evans nosym_str = NULL; 29110a4fa49Srie } 29210a4fa49Srie break; 29310a4fa49Srie 29410a4fa49Srie case CI_BIND_GUARD: 29510a4fa49Srie case CI_BIND_CLEAR: 29610a4fa49Srie case CI_THR_SELF: 2972a8d6ebaSRod Evans case CI_CRITICAL: 29810a4fa49Srie /* 29910a4fa49Srie * If the global vector is unset, or this is the primary 30010a4fa49Srie * link-map, set the global vector. 30110a4fa49Srie */ 30243d7826aSRod Evans if ((gptr == NULL) || (lml->lm_flags & LML_FLG_BASELM)) 30310a4fa49Srie glcs[tag].lc_un.lc_ptr = lptr; 30410a4fa49Srie 30510a4fa49Srie /* FALLTHROUGH */ 30610a4fa49Srie 30710a4fa49Srie case CI_TLS_MODADD: 30810a4fa49Srie case CI_TLS_MODREM: 30910a4fa49Srie case CI_TLS_STATMOD: 31010a4fa49Srie case CI_THRINIT: 31110a4fa49Srie threaded++; 31210a4fa49Srie break; 31310a4fa49Srie 31410a4fa49Srie case CI_VERSION: 31510a4fa49Srie if ((rtld_flags2 & RT_FL2_RTLDSEEN) == 0) { 31657ef7aa9SRod Evans Aliste idx; 31757ef7aa9SRod Evans Lm_list *lml2; 31857ef7aa9SRod Evans int version; 31943d7826aSRod Evans 32010a4fa49Srie rtld_flags2 |= RT_FL2_RTLDSEEN; 32110a4fa49Srie 3228cd45542Sraf version = funcs->ci_un.ci_val; 3238cd45542Sraf #if defined(CI_V_FIVE) 3248cd45542Sraf if (version >= CI_V_FIVE) { 3258cd45542Sraf thr_flg_nolock = THR_FLG_NOLOCK; 3268cd45542Sraf thr_flg_reenter = THR_FLG_REENTER; 3278cd45542Sraf } 3288cd45542Sraf #endif 32943d7826aSRod Evans if (version < CI_V_FOUR) 33010a4fa49Srie break; 33110a4fa49Srie 33243d7826aSRod Evans rtld_flags2 |= RT_FL2_UNIFPROC; 33343d7826aSRod Evans 33443d7826aSRod Evans /* 33543d7826aSRod Evans * We might have seen an auditor which is not 33643d7826aSRod Evans * dependent on libc. Such an auditor's link 33743d7826aSRod Evans * map list has LML_FLG_HOLDLOCK set. This 33843d7826aSRod Evans * lock needs to be dropped. Refer to 33943d7826aSRod Evans * audit_setup() in audit.c. 34043d7826aSRod Evans */ 34143d7826aSRod Evans if ((rtld_flags2 & RT_FL2_HASAUDIT) == 0) 34243d7826aSRod Evans break; 34343d7826aSRod Evans 34443d7826aSRod Evans /* 34557ef7aa9SRod Evans * Yes, we did. Take care of them. 34643d7826aSRod Evans */ 34757ef7aa9SRod Evans for (APLIST_TRAVERSE(dynlm_list, idx, lml2)) { 34843d7826aSRod Evans Rt_map *map = (Rt_map *)lml2->lm_head; 34943d7826aSRod Evans 35043d7826aSRod Evans if (FLAGS(map) & FLG_RT_AUDIT) { 35143d7826aSRod Evans lml2->lm_flags &= 35243d7826aSRod Evans ~LML_FLG_HOLDLOCK; 35310a4fa49Srie } 35410a4fa49Srie } 35510a4fa49Srie } 35610a4fa49Srie break; 35710a4fa49Srie 35810a4fa49Srie default: 35910a4fa49Srie break; 36010a4fa49Srie } 36110a4fa49Srie } 36210a4fa49Srie 36343d7826aSRod Evans if (threaded) { 36443d7826aSRod Evans /* 36543d7826aSRod Evans * If a version of libc gives us only a subset of the TLS 36643d7826aSRod Evans * interfaces, it's confused and we discard the whole lot. 36743d7826aSRod Evans */ 36843d7826aSRod Evans if ((lcp[CI_TLS_MODADD].lc_un.lc_func && 36943d7826aSRod Evans lcp[CI_TLS_MODREM].lc_un.lc_func && 37043d7826aSRod Evans lcp[CI_TLS_STATMOD].lc_un.lc_func) == NULL) { 37143d7826aSRod Evans lcp[CI_TLS_MODADD].lc_un.lc_func = NULL; 37243d7826aSRod Evans lcp[CI_TLS_MODREM].lc_un.lc_func = NULL; 37343d7826aSRod Evans lcp[CI_TLS_STATMOD].lc_un.lc_func = NULL; 37443d7826aSRod Evans } 37510a4fa49Srie 37643d7826aSRod Evans /* 37743d7826aSRod Evans * Indicate that we're now thread capable. 37843d7826aSRod Evans */ 37943d7826aSRod Evans if ((lml->lm_flags & LML_FLG_RTLDLM) == 0) 38043d7826aSRod Evans rtld_flags |= RT_FL_THREADS; 38110a4fa49Srie } 38210a4fa49Srie 38343d7826aSRod Evans if (entry) 38443d7826aSRod Evans leave(lml, 0); 38510a4fa49Srie } 38610a4fa49Srie 38710a4fa49Srie /* 38810a4fa49Srie * At this point we know we have a set of objects that have been fully analyzed 38910a4fa49Srie * and relocated. Prior to the next major step of running .init sections (ie. 39010a4fa49Srie * running user code), retrieve any RTLDINFO interfaces. 39110a4fa49Srie */ 39210a4fa49Srie int 39310a4fa49Srie rt_get_extern(Lm_list *lml, Rt_map *lmp) 39410a4fa49Srie { 39510a4fa49Srie if (lml->lm_rti) { 396cce0e03bSab Aliste idx; 39710a4fa49Srie Rti_desc *rti; 39810a4fa49Srie 399cce0e03bSab for (ALIST_TRAVERSE(lml->lm_rti, idx, rti)) 40010a4fa49Srie get_lcinterface(rti->rti_lmp, rti->rti_info); 40110a4fa49Srie 40210a4fa49Srie free(lml->lm_rti); 40310a4fa49Srie lml->lm_rti = 0; 40410a4fa49Srie } 40510a4fa49Srie 40610a4fa49Srie /* 40710a4fa49Srie * Perform some sanity checks. If we have TLS requirements we better 40810a4fa49Srie * have the associated external interfaces. 40910a4fa49Srie */ 41043d7826aSRod Evans if (lml->lm_tls && 41143d7826aSRod Evans (lml->lm_lcs[CI_TLS_STATMOD].lc_un.lc_func == NULL)) { 412d326b23bSrie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_TLS_NOSUPPORT), 41310a4fa49Srie NAME(lmp)); 41410a4fa49Srie return (0); 41510a4fa49Srie } 41610a4fa49Srie return (1); 41710a4fa49Srie } 41810a4fa49Srie 41943d7826aSRod Evans /* 42043d7826aSRod Evans * Provide an interface for libc to communicate additional interface 42143d7826aSRod Evans * information. 42243d7826aSRod Evans */ 42343d7826aSRod Evans void 42443d7826aSRod Evans _ld_libc(void *ptr) 42543d7826aSRod Evans { 42643d7826aSRod Evans get_lcinterface(_caller(caller(), CL_EXECDEF), (Lc_interface *)ptr); 42743d7826aSRod Evans } 42843d7826aSRod Evans 42910a4fa49Srie static int bindmask = 0; 43010a4fa49Srie 43110a4fa49Srie int 4328cd45542Sraf rt_bind_guard(int flags) 43310a4fa49Srie { 43410a4fa49Srie int (*fptr)(int); 4358cd45542Sraf int bindflag; 43610a4fa49Srie 43710a4fa49Srie if ((fptr = glcs[CI_BIND_GUARD].lc_un.lc_func) != NULL) { 4388cd45542Sraf return ((*fptr)(flags)); 43910a4fa49Srie } else { 4408cd45542Sraf bindflag = (flags & THR_FLG_RTLD); 44110a4fa49Srie if ((bindflag & bindmask) == 0) { 44210a4fa49Srie bindmask |= bindflag; 44310a4fa49Srie return (1); 44410a4fa49Srie } 44510a4fa49Srie return (0); 44610a4fa49Srie } 44710a4fa49Srie } 44810a4fa49Srie 44910a4fa49Srie int 4508cd45542Sraf rt_bind_clear(int flags) 45110a4fa49Srie { 45210a4fa49Srie int (*fptr)(int); 4538cd45542Sraf int bindflag; 45410a4fa49Srie 45510a4fa49Srie if ((fptr = glcs[CI_BIND_CLEAR].lc_un.lc_func) != NULL) { 4568cd45542Sraf return ((*fptr)(flags)); 45710a4fa49Srie } else { 4588cd45542Sraf bindflag = (flags & THR_FLG_RTLD); 45910a4fa49Srie if (bindflag == 0) 46010a4fa49Srie return (bindmask); 46110a4fa49Srie else { 46210a4fa49Srie bindmask &= ~bindflag; 46310a4fa49Srie return (0); 46410a4fa49Srie } 46510a4fa49Srie } 46610a4fa49Srie } 46710a4fa49Srie 46810a4fa49Srie /* 46910a4fa49Srie * Make sure threads have been initialized. This interface is called once for 47010a4fa49Srie * each link-map list. 47110a4fa49Srie */ 47210a4fa49Srie void 47310a4fa49Srie rt_thr_init(Lm_list *lml) 47410a4fa49Srie { 47510a4fa49Srie void (*fptr)(void); 47610a4fa49Srie 47743d7826aSRod Evans if ((fptr = 47843d7826aSRod Evans (void (*)())lml->lm_lcs[CI_THRINIT].lc_un.lc_func) != NULL) { 47943d7826aSRod Evans lml->lm_lcs[CI_THRINIT].lc_un.lc_func = NULL; 4802020b2b6SRod Evans 4812020b2b6SRod Evans leave(lml, thr_flg_reenter); 48210a4fa49Srie (*fptr)(); 4838cd45542Sraf (void) enter(thr_flg_reenter); 484dde769a2SRod Evans 485dde769a2SRod Evans /* 486dde769a2SRod Evans * If this is an alternative link-map list, and this is the 487dde769a2SRod Evans * first call to initialize threads, don't let the destination 488dde769a2SRod Evans * libc be deleted. It is possible that an auditors complete 489dde769a2SRod Evans * initialization fails, but there is presently no main link-map 490dde769a2SRod Evans * list. As this libc has established the thread pointer, don't 491dde769a2SRod Evans * delete this libc, otherwise the initialization of libc on the 492dde769a2SRod Evans * main link-map can be compromised during its threads 493dde769a2SRod Evans * initialization. 494dde769a2SRod Evans */ 495dde769a2SRod Evans if (((lml->lm_flags & LML_FLG_BASELM) == 0) && 496dde769a2SRod Evans ((rtld_flags2 & RT_FL2_PLMSETUP) == 0)) 497dde769a2SRod Evans MODE(lml->lm_lcs[CI_THRINIT].lc_lmp) |= RTLD_NODELETE; 49810a4fa49Srie } 49910a4fa49Srie } 50010a4fa49Srie 50110a4fa49Srie thread_t 50210a4fa49Srie rt_thr_self() 50310a4fa49Srie { 50410a4fa49Srie thread_t (*fptr)(void); 50510a4fa49Srie 50610a4fa49Srie if ((fptr = (thread_t (*)())glcs[CI_THR_SELF].lc_un.lc_func) != NULL) 50710a4fa49Srie return ((*fptr)()); 50810a4fa49Srie 50910a4fa49Srie return (1); 51010a4fa49Srie } 51110a4fa49Srie 51210a4fa49Srie int 5132a8d6ebaSRod Evans rt_mutex_lock(Rt_lock *mp) 51410a4fa49Srie { 51510a4fa49Srie return (_lwp_mutex_lock((lwp_mutex_t *)mp)); 51610a4fa49Srie } 51710a4fa49Srie 51810a4fa49Srie int 5192a8d6ebaSRod Evans rt_mutex_unlock(Rt_lock *mp) 52010a4fa49Srie { 52110a4fa49Srie return (_lwp_mutex_unlock((lwp_mutex_t *)mp)); 52210a4fa49Srie } 52310a4fa49Srie 5242a8d6ebaSRod Evans /* 5252a8d6ebaSRod Evans * Test whether we're in a libc critical region. Certain function references, 5262a8d6ebaSRod Evans * like the "mem*" family, might require binding. Although these functions can 5272a8d6ebaSRod Evans * safely bind to auxiliary filtees, they should not be captured by auditors. 5282a8d6ebaSRod Evans */ 5292a8d6ebaSRod Evans int 5302a8d6ebaSRod Evans rt_critical() 5312a8d6ebaSRod Evans { 5322a8d6ebaSRod Evans int (*fptr)(void); 5332a8d6ebaSRod Evans 5342a8d6ebaSRod Evans if ((fptr = glcs[CI_CRITICAL].lc_un.lc_func) != NULL) 5352a8d6ebaSRod Evans return ((*fptr)()); 5362a8d6ebaSRod Evans 5372a8d6ebaSRod Evans return (0); 5382a8d6ebaSRod Evans } 5392a8d6ebaSRod Evans 54010a4fa49Srie /* 54110a4fa49Srie * Mutex interfaces to resolve references from any objects extracted from 54210a4fa49Srie * libc_pic.a. Note, as ld.so.1 is essentially single threaded these can be 54310a4fa49Srie * noops. 54410a4fa49Srie */ 5457257d1b4Sraf #pragma weak lmutex_lock = mutex_lock 54610a4fa49Srie /* ARGSUSED */ 54710a4fa49Srie int 5487257d1b4Sraf mutex_lock(mutex_t *mp) 54910a4fa49Srie { 55010a4fa49Srie return (0); 55110a4fa49Srie } 55210a4fa49Srie 5537257d1b4Sraf #pragma weak lmutex_unlock = mutex_unlock 55410a4fa49Srie /* ARGSUSED */ 55510a4fa49Srie int 5567257d1b4Sraf mutex_unlock(mutex_t *mp) 55710a4fa49Srie { 55810a4fa49Srie return (0); 55910a4fa49Srie } 56010a4fa49Srie 561494a4c51Sraf /* ARGSUSED */ 562494a4c51Sraf int 5637257d1b4Sraf mutex_init(mutex_t *mp, int type, void *arg) 564494a4c51Sraf { 565494a4c51Sraf return (0); 566494a4c51Sraf } 567494a4c51Sraf 568494a4c51Sraf /* ARGSUSED */ 569494a4c51Sraf int 5707257d1b4Sraf mutex_destroy(mutex_t *mp) 571494a4c51Sraf { 572494a4c51Sraf return (0); 573494a4c51Sraf } 574494a4c51Sraf 57510a4fa49Srie /* 57610a4fa49Srie * This is needed to satisfy sysconf() (case _SC_THREAD_STACK_MIN) 57710a4fa49Srie */ 57810a4fa49Srie size_t 5797257d1b4Sraf thr_min_stack() 58010a4fa49Srie { 5812020b2b6SRod Evans return (sizeof (uintptr_t) * 1024); 58210a4fa49Srie } 58310a4fa49Srie 584*23a1cceaSRoger A. Faulkner /* 585*23a1cceaSRoger A. Faulkner * Local str[n]casecmp() interfaces for the dynamic linker, 586*23a1cceaSRoger A. Faulkner * to avoid problems when linking with libc_pic.a 587*23a1cceaSRoger A. Faulkner */ 588*23a1cceaSRoger A. Faulkner int 589*23a1cceaSRoger A. Faulkner strcasecmp(const char *s1, const char *s2) 590*23a1cceaSRoger A. Faulkner { 591*23a1cceaSRoger A. Faulkner extern int ascii_strcasecmp(const char *, const char *); 592*23a1cceaSRoger A. Faulkner 593*23a1cceaSRoger A. Faulkner return (ascii_strcasecmp(s1, s2)); 594*23a1cceaSRoger A. Faulkner } 595*23a1cceaSRoger A. Faulkner 596*23a1cceaSRoger A. Faulkner int 597*23a1cceaSRoger A. Faulkner strncasecmp(const char *s1, const char *s2, size_t n) 598*23a1cceaSRoger A. Faulkner { 599*23a1cceaSRoger A. Faulkner extern int ascii_strncasecmp(const char *, const char *, size_t); 600*23a1cceaSRoger A. Faulkner 601*23a1cceaSRoger A. Faulkner return (ascii_strncasecmp(s1, s2, n)); 602*23a1cceaSRoger A. Faulkner } 603*23a1cceaSRoger A. Faulkner 604a574db85Sraf /* 605a574db85Sraf * The following functions are cancellation points in libc. 606a574db85Sraf * They are called from other functions in libc that we extract 607a574db85Sraf * and use directly. We don't do cancellation while we are in 608a574db85Sraf * the dynamic linker, so we redefine these to call the primitive, 609a574db85Sraf * non-cancellation interfaces. 610a574db85Sraf */ 611a574db85Sraf int 6127257d1b4Sraf close(int fildes) 613a574db85Sraf { 614a574db85Sraf extern int __close(int); 615a574db85Sraf 616a574db85Sraf return (__close(fildes)); 617a574db85Sraf } 618a574db85Sraf 619a574db85Sraf int 6207257d1b4Sraf fcntl(int fildes, int cmd, ...) 621a574db85Sraf { 622a574db85Sraf extern int __fcntl(int, int, ...); 623a574db85Sraf intptr_t arg; 624a574db85Sraf va_list ap; 625a574db85Sraf 626a574db85Sraf va_start(ap, cmd); 627a574db85Sraf arg = va_arg(ap, intptr_t); 628a574db85Sraf va_end(ap); 629a574db85Sraf return (__fcntl(fildes, cmd, arg)); 630a574db85Sraf } 631a574db85Sraf 632a574db85Sraf int 6337257d1b4Sraf open(const char *path, int oflag, ...) 634a574db85Sraf { 6358fd04b83SRoger A. Faulkner extern int __open(const char *, int, mode_t); 636a574db85Sraf mode_t mode; 637a574db85Sraf va_list ap; 638a574db85Sraf 639a574db85Sraf va_start(ap, oflag); 640a574db85Sraf mode = va_arg(ap, mode_t); 641a574db85Sraf va_end(ap); 642a574db85Sraf return (__open(path, oflag, mode)); 643a574db85Sraf } 644a574db85Sraf 645a574db85Sraf int 6467257d1b4Sraf openat(int fd, const char *path, int oflag, ...) 647a574db85Sraf { 6488fd04b83SRoger A. Faulkner extern int __openat(int, const char *, int, mode_t); 649a574db85Sraf mode_t mode; 650a574db85Sraf va_list ap; 651a574db85Sraf 652a574db85Sraf va_start(ap, oflag); 653a574db85Sraf mode = va_arg(ap, mode_t); 654a574db85Sraf va_end(ap); 655a574db85Sraf return (__openat(fd, path, oflag, mode)); 656a574db85Sraf } 657a574db85Sraf 658a574db85Sraf ssize_t 6597257d1b4Sraf read(int fd, void *buf, size_t size) 660a574db85Sraf { 661a574db85Sraf extern ssize_t __read(int, void *, size_t); 662a574db85Sraf return (__read(fd, buf, size)); 663a574db85Sraf } 664a574db85Sraf 665a574db85Sraf ssize_t 6667257d1b4Sraf write(int fd, const void *buf, size_t size) 667a574db85Sraf { 668a574db85Sraf extern ssize_t __write(int, const void *, size_t); 669a574db85Sraf return (__write(fd, buf, size)); 670a574db85Sraf } 671