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 /* 2356deab07SRod Evans * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 2410a4fa49Srie * Use is subject to license terms. 2510a4fa49Srie */ 26a574db85Sraf 2710a4fa49Srie /* 2810a4fa49Srie * Implementation of all external interfaces between ld.so.1 and libc. 2910a4fa49Srie * 3010a4fa49Srie * This file started as a set of routines that provided synchronization and 3143d7826aSRod Evans * locking operations using calls to libthread. libthread has merged with libc 3243d7826aSRod Evans * under the Unified Process Model (UPM), and things have gotten a lot simpler. 3343d7826aSRod Evans * This file continues to establish and redirect various events within ld.so.1 3443d7826aSRod Evans * to interfaces within libc. 3510a4fa49Srie * 3610a4fa49Srie * Until libc is loaded and relocated, any external interfaces are captured 3710a4fa49Srie * locally. Each link-map list maintains its own set of external vectors, as 3810a4fa49Srie * each link-map list typically provides its own libc. Although this per-link- 3910a4fa49Srie * map list vectoring provides a degree of flexibility, there is a protocol 4010a4fa49Srie * expected when calling various libc interfaces. 4110a4fa49Srie * 4210a4fa49Srie * i. Any new alternative link-map list should call CI_THRINIT, and then call 4310a4fa49Srie * CI_TLS_MODADD to register any TLS for each object of that link-map list 4410a4fa49Srie * (this item is labeled i. as auditors can be the first objects loaded, 4510a4fa49Srie * and they exist on their own lik-map list). 4610a4fa49Srie * 4710a4fa49Srie * ii. For the primary link-map list, CI_TLS_STATMOD must be called first to 4810a4fa49Srie * register any static TLS. This routine is called regardless of there 4910a4fa49Srie * being any TLS, as this routine also establishes the link-map list as the 5010a4fa49Srie * primary list and fixes the association of uberdata). CI_THRINIT should 5110a4fa49Srie * then be called. 5210a4fa49Srie * 5310a4fa49Srie * iii. Any objects added to an existing link-map list (primary or alternative) 5410a4fa49Srie * should call CI_TLS_MODADD to register any additional TLS. 5510a4fa49Srie * 5610a4fa49Srie * These events are established by: 5710a4fa49Srie * 5810a4fa49Srie * i. Typically, libc is loaded as part of the primary dependencies of any 5910a4fa49Srie * link-map list (since the Unified Process Model (UPM), libc can't be 6010a4fa49Srie * lazily loaded). To minimize the possibility of loading and registering 6110a4fa49Srie * objects, and then tearing them down (because of a relocation error), 6210a4fa49Srie * external vectors are established as part of load_completion(). This 6310a4fa49Srie * routine is called on completion of any operation that can cause objects 6410a4fa49Srie * to be loaded. This point of control insures the objects have been fully 6510a4fa49Srie * analyzed and relocated, and moved to their controlling link-map list. 6610a4fa49Srie * The external vectors are established prior to any .inits being fired. 6710a4fa49Srie * 6810a4fa49Srie * ii. Calls to CI_THRINIT, and CI_TLS_MODADD also occur as part of 6910a4fa49Srie * load_completion(). CI_THRINIT is only called once for each link-map 7010a4fa49Srie * control list. 7110a4fa49Srie * 7210a4fa49Srie * iii. Calls to CI_TLS_STATMOD, and CI_THRINIT occur for the primary link-map 7310a4fa49Srie * list in the final stages of setup(). 7410a4fa49Srie * 7510a4fa49Srie * The interfaces provide by libc can be divided into two families. The first 7610a4fa49Srie * family consists of those interfaces that should be called from the link-map 7710a4fa49Srie * list. It's possible that these interfaces convey state concerning the 7810a4fa49Srie * link-map list they are part of: 7910a4fa49Srie * 8010a4fa49Srie * CI_ATEXIT 8110a4fa49Srie * CI TLS_MODADD 8210a4fa49Srie * CI_TLS_MODREM 8310a4fa49Srie * CI_TLS_STATMOD 8410a4fa49Srie * CI_THRINIT 8510a4fa49Srie * 8610a4fa49Srie * The second family are global in nature, that is, the link-map list from 8710a4fa49Srie * which they are called provides no state information. In fact, for 8810a4fa49Srie * CI_BIND_GUARD, the calling link-map isn't even known. The link-map can only 8910a4fa49Srie * be deduced after ld.so.1's global lock has been obtained. Therefore, the 9010a4fa49Srie * following interfaces are also maintained as global: 9110a4fa49Srie * 9210a4fa49Srie * CI_LCMESSAGES 9310a4fa49Srie * CI_BIND_GUARD 9410a4fa49Srie * CI_BIND_CLEAR 9510a4fa49Srie * CI_THR_SELF 9610a4fa49Srie * 9710a4fa49Srie * Note, it is possible that these global interfaces are obtained from an 9810a4fa49Srie * alternative link-map list that gets torn down because of a processing 9910a4fa49Srie * failure (unlikely, because the link-map list components must be analyzed 10010a4fa49Srie * and relocated prior to load_completion(), but perhaps the tear down is still 10110a4fa49Srie * a possibility). Thus the global interfaces may have to be replaced. Once 10210a4fa49Srie * the interfaces have been obtained from the primary link-map, they can 10310a4fa49Srie * remain fixed, as the primary link-map isn't going to go anywhere. 10410a4fa49Srie * 10510a4fa49Srie * The last wrinkle in the puzzle is what happens if an alternative link-map 10610a4fa49Srie * is loaded with no libc dependency? In this case, the alternative objects 10710a4fa49Srie * can not call CI_THRINIT, can not be allowed to use TLS, and will not receive 10810a4fa49Srie * any atexit processing. 10910a4fa49Srie * 11010a4fa49Srie * The history of these external interfaces is defined by their version: 11110a4fa49Srie * 11210a4fa49Srie * TI_VERSION == 1 11310a4fa49Srie * Under this model libthread provided rw_rwlock/rw_unlock, through which 11410a4fa49Srie * all rt_mutex_lock/rt_mutex_unlock calls were vectored. 11510a4fa49Srie * Under libc/libthread these interfaces provided _sigon/_sigoff (unlike 11610a4fa49Srie * lwp/libthread that provided signal blocking via bind_guard/bind_clear). 11710a4fa49Srie * 11810a4fa49Srie * TI_VERSION == 2 11910a4fa49Srie * Under this model only libthreads bind_guard/bind_clear and thr_self 12010a4fa49Srie * interfaces were used. Both libthreads blocked signals under the 12110a4fa49Srie * bind_guard/bind_clear interfaces. Lower level locking is derived 12210a4fa49Srie * from internally bound _lwp_ interfaces. This removes recursive 12310a4fa49Srie * problems encountered when obtaining locking interfaces from libthread. 12410a4fa49Srie * The use of mutexes over reader/writer locks also enables the use of 12510a4fa49Srie * condition variables for controlling thread concurrency (allows access 12610a4fa49Srie * to objects only after their .init has completed). 12710a4fa49Srie * 12810a4fa49Srie * NOTE, the TI_VERSION indicated the ti_interface version number, where the 12910a4fa49Srie * ti_interface was a large vector of functions passed to both libc (to override 13010a4fa49Srie * the thread stub interfaces) and ld.so.1. ld.so.1 used only a small subset of 13110a4fa49Srie * these interfaces. 13210a4fa49Srie * 13310a4fa49Srie * CI_VERSION == 1 13410a4fa49Srie * Introduced with CI_VERSION & CI_ATEXIT 13510a4fa49Srie * 13610a4fa49Srie * CI_VERSION == 2 (Solaris 8 update 2). 13710a4fa49Srie * Added support for CI_LCMESSAGES 13810a4fa49Srie * 13910a4fa49Srie * CI_VERSION == 3 (Solaris 9). 14010a4fa49Srie * Added the following versions to the CI table: 14110a4fa49Srie * 14210a4fa49Srie * CI_BIND_GUARD, CI_BIND_CLEAR, CI_THR_SELF 14310a4fa49Srie * CI_TLS_MODADD, CI_TLS_MOD_REMOVE, CI_TLS_STATMOD 14410a4fa49Srie * 14510a4fa49Srie * This version introduced the DT_SUNW_RTLDINFO structure as a mechanism 14610a4fa49Srie * to handshake with ld.so.1. 14710a4fa49Srie * 14810a4fa49Srie * CI_VERSION == 4 (Solaris 10). 14910a4fa49Srie * Added the CI_THRINIT handshake as part of the libc/libthread unified 15010a4fa49Srie * process model. libc now initializes the current thread pointer from 15110a4fa49Srie * this interface (and no longer relies on the INITFIRST flag - which 15210a4fa49Srie * others have started to camp out on). 15310a4fa49Srie * 154*2a8d6ebaSRod Evans * CI_VERSION == 5 (Solaris 11). 155*2a8d6ebaSRod Evans * Use of "protected" references within libc, so that symbols are 156*2a8d6ebaSRod Evans * pre-bound, and don't require ld.so.1 binding. This implementation 157*2a8d6ebaSRod Evans * protects libc's critical regions from being vectored to auditors. 158*2a8d6ebaSRod Evans * 159*2a8d6ebaSRod Evans * CI_VERSION == 6 (Solaris 11). 160*2a8d6ebaSRod Evans * Added the CI_CRITICAL handshake, to allow "mem*" family to be reexposed 161*2a8d6ebaSRod Evans * as "global", and thus be redirected to auxiliary filters. 162*2a8d6ebaSRod Evans * 16310a4fa49Srie * Release summary: 16410a4fa49Srie * 16510a4fa49Srie * Solaris 8 CI_ATEXIT via _ld_libc() 16610a4fa49Srie * TI_* via _ld_concurrency() 16710a4fa49Srie * 16810a4fa49Srie * Solaris 9 CI_ATEXIT and CI_LCMESSAGES via _ld_libc() 16910a4fa49Srie * CI_* via RTLDINFO and _ld_libc() - new libthread 17010a4fa49Srie * TI_* via _ld_concurrency() - old libthread 17110a4fa49Srie * 17210a4fa49Srie * Solaris 10 CI_ATEXIT and CI_LCMESSAGES via _ld_libc() 17310a4fa49Srie * CI_* via RTLDINFO and _ld_libc() - new libthread 17410a4fa49Srie */ 175a574db85Sraf 176a574db85Sraf #include <sys/debug.h> 177a574db85Sraf #include <synch.h> 178a574db85Sraf #include <signal.h> 179a574db85Sraf #include <thread.h> 180a574db85Sraf #include <synch.h> 181a574db85Sraf #include <strings.h> 182a574db85Sraf #include <stdio.h> 183a574db85Sraf #include <debug.h> 184a574db85Sraf #include <libc_int.h> 185a574db85Sraf #include "_elf.h" 186a574db85Sraf #include "_rtld.h" 18710a4fa49Srie 18810a4fa49Srie /* 18910a4fa49Srie * This interface provides the unified process model communication between 19043d7826aSRod Evans * ld.so.1 and libc. This interface can be called a number of times: 19143d7826aSRod Evans * 19243d7826aSRod Evans * - Initially, this interface is called to process RTLDINFO. This data 19343d7826aSRod Evans * structure is typically provided by libc, and contains the address of 19443d7826aSRod Evans * libc interfaces that must be called to initialize threads information. 19543d7826aSRod Evans * 19643d7826aSRod Evans * - _ld_libc(), this interface can also be called by libc at process 19743d7826aSRod Evans * initialization, after libc has been loaded and relocated, but before 19843d7826aSRod Evans * control has been passed to any user code (.init's or main()). This 19943d7826aSRod Evans * call provides additional libc interface information that ld.so.1 must 20043d7826aSRod Evans * call during process execution. 20143d7826aSRod Evans * 20243d7826aSRod Evans * - _ld_libc() can also be called by libc during process execution to 20343d7826aSRod Evans * re-establish interfaces such as the locale. 20410a4fa49Srie */ 20543d7826aSRod Evans static void 20610a4fa49Srie get_lcinterface(Rt_map *lmp, Lc_interface *funcs) 20710a4fa49Srie { 20843d7826aSRod Evans int threaded = 0, entry = 0, tag; 20910a4fa49Srie Lm_list *lml; 21010a4fa49Srie Lc_desc *lcp; 21110a4fa49Srie 21243d7826aSRod Evans if ((lmp == NULL) || (funcs == NULL)) 21310a4fa49Srie return; 21410a4fa49Srie 21543d7826aSRod Evans /* 21643d7826aSRod Evans * Once the process is active, ensure we grab a lock. 21743d7826aSRod Evans */ 21843d7826aSRod Evans if (rtld_flags & RT_FL_APPLIC) 21943d7826aSRod Evans entry = enter(0); 22043d7826aSRod Evans 22110a4fa49Srie lml = LIST(lmp); 22210a4fa49Srie lcp = &lml->lm_lcs[0]; 22310a4fa49Srie 22410a4fa49Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 22510a4fa49Srie 22610a4fa49Srie for (tag = funcs->ci_tag; tag; tag = (++funcs)->ci_tag) { 22710a4fa49Srie char *gptr; 22810a4fa49Srie char *lptr = funcs->ci_un.ci_ptr; 22910a4fa49Srie 23010a4fa49Srie DBG_CALL(Dbg_util_lcinterface(lmp, tag, lptr)); 23110a4fa49Srie 23210a4fa49Srie if (tag >= CI_MAX) 23310a4fa49Srie continue; 23410a4fa49Srie 23510a4fa49Srie /* 23610a4fa49Srie * Maintain all interfaces on a per-link-map basis. Note, for 23710a4fa49Srie * most interfaces, only the first interface is used for any 23810a4fa49Srie * link-map list. This prevents accidents with developers who 23910a4fa49Srie * manage to load two different versions of libc. 24010a4fa49Srie */ 24110a4fa49Srie if ((lcp[tag].lc_lmp) && 24210a4fa49Srie (tag != CI_LCMESSAGES) && (tag != CI_VERSION)) { 24310a4fa49Srie DBG_CALL(Dbg_unused_lcinterface(lmp, 24410a4fa49Srie lcp[tag].lc_lmp, tag)); 24510a4fa49Srie continue; 24610a4fa49Srie } 24710a4fa49Srie 24810a4fa49Srie lcp[tag].lc_un.lc_ptr = lptr; 24910a4fa49Srie lcp[tag].lc_lmp = lmp; 25010a4fa49Srie 25110a4fa49Srie gptr = glcs[tag].lc_un.lc_ptr; 25210a4fa49Srie 25310a4fa49Srie /* 25410a4fa49Srie * Process any interfaces that must be maintained on a global 25510a4fa49Srie * basis. 25610a4fa49Srie */ 25710a4fa49Srie switch (tag) { 25810a4fa49Srie case CI_ATEXIT: 25910a4fa49Srie break; 26010a4fa49Srie 26110a4fa49Srie case CI_LCMESSAGES: 26210a4fa49Srie /* 26310a4fa49Srie * At startup, ld.so.1 can establish a locale from one 26410a4fa49Srie * of the locale family of environment variables (see 26510a4fa49Srie * ld_str_env() and readenv_user()). During process 26610a4fa49Srie * execution the locale can also be changed by the user. 26710a4fa49Srie * This interface is called from libc should the locale 26810a4fa49Srie * be modified. Presently, only one global locale is 26910a4fa49Srie * maintained for all link-map lists, and only objects 27010a4fa49Srie * on the primrary link-map may change this locale. 27110a4fa49Srie */ 27210a4fa49Srie if ((lml->lm_flags & LML_FLG_BASELM) && 27343d7826aSRod Evans ((gptr == NULL) || (strcmp(gptr, lptr) != 0))) { 27410a4fa49Srie /* 27510a4fa49Srie * If we've obtained a message locale (typically 27610a4fa49Srie * supplied via libc's setlocale()), then 27710a4fa49Srie * register the locale for use in dgettext() so 27810a4fa49Srie * as to reestablish the locale for ld.so.1's 27910a4fa49Srie * messages. 28010a4fa49Srie */ 28110a4fa49Srie if (gptr) { 28210a4fa49Srie free((void *)gptr); 28310a4fa49Srie rtld_flags |= RT_FL_NEWLOCALE; 28410a4fa49Srie } 28510a4fa49Srie glcs[tag].lc_un.lc_ptr = strdup(lptr); 28610a4fa49Srie 28710a4fa49Srie /* 28810a4fa49Srie * Clear any cached messages. 28910a4fa49Srie */ 29043d7826aSRod Evans bzero(err_strs, sizeof (err_strs)); 29143d7826aSRod Evans nosym_str = NULL; 29210a4fa49Srie } 29310a4fa49Srie break; 29410a4fa49Srie 29510a4fa49Srie case CI_BIND_GUARD: 29610a4fa49Srie case CI_BIND_CLEAR: 29710a4fa49Srie case CI_THR_SELF: 298*2a8d6ebaSRod Evans case CI_CRITICAL: 29910a4fa49Srie /* 30010a4fa49Srie * If the global vector is unset, or this is the primary 30110a4fa49Srie * link-map, set the global vector. 30210a4fa49Srie */ 30343d7826aSRod Evans if ((gptr == NULL) || (lml->lm_flags & LML_FLG_BASELM)) 30410a4fa49Srie glcs[tag].lc_un.lc_ptr = lptr; 30510a4fa49Srie 30610a4fa49Srie /* FALLTHROUGH */ 30710a4fa49Srie 30810a4fa49Srie case CI_TLS_MODADD: 30910a4fa49Srie case CI_TLS_MODREM: 31010a4fa49Srie case CI_TLS_STATMOD: 31110a4fa49Srie case CI_THRINIT: 31210a4fa49Srie threaded++; 31310a4fa49Srie break; 31410a4fa49Srie 31510a4fa49Srie case CI_VERSION: 31610a4fa49Srie if ((rtld_flags2 & RT_FL2_RTLDSEEN) == 0) { 31757ef7aa9SRod Evans Aliste idx; 31857ef7aa9SRod Evans Lm_list *lml2; 31957ef7aa9SRod Evans int version; 32043d7826aSRod Evans 32110a4fa49Srie rtld_flags2 |= RT_FL2_RTLDSEEN; 32210a4fa49Srie 3238cd45542Sraf version = funcs->ci_un.ci_val; 3248cd45542Sraf #if defined(CI_V_FIVE) 3258cd45542Sraf if (version >= CI_V_FIVE) { 3268cd45542Sraf thr_flg_nolock = THR_FLG_NOLOCK; 3278cd45542Sraf thr_flg_reenter = THR_FLG_REENTER; 3288cd45542Sraf } 3298cd45542Sraf #endif 33043d7826aSRod Evans if (version < CI_V_FOUR) 33110a4fa49Srie break; 33210a4fa49Srie 33343d7826aSRod Evans rtld_flags2 |= RT_FL2_UNIFPROC; 33443d7826aSRod Evans 33543d7826aSRod Evans /* 33643d7826aSRod Evans * We might have seen an auditor which is not 33743d7826aSRod Evans * dependent on libc. Such an auditor's link 33843d7826aSRod Evans * map list has LML_FLG_HOLDLOCK set. This 33943d7826aSRod Evans * lock needs to be dropped. Refer to 34043d7826aSRod Evans * audit_setup() in audit.c. 34143d7826aSRod Evans */ 34243d7826aSRod Evans if ((rtld_flags2 & RT_FL2_HASAUDIT) == 0) 34343d7826aSRod Evans break; 34443d7826aSRod Evans 34543d7826aSRod Evans /* 34657ef7aa9SRod Evans * Yes, we did. Take care of them. 34743d7826aSRod Evans */ 34857ef7aa9SRod Evans for (APLIST_TRAVERSE(dynlm_list, idx, lml2)) { 34943d7826aSRod Evans Rt_map *map = (Rt_map *)lml2->lm_head; 35043d7826aSRod Evans 35143d7826aSRod Evans if (FLAGS(map) & FLG_RT_AUDIT) { 35243d7826aSRod Evans lml2->lm_flags &= 35343d7826aSRod Evans ~LML_FLG_HOLDLOCK; 35410a4fa49Srie } 35510a4fa49Srie } 35610a4fa49Srie } 35710a4fa49Srie break; 35810a4fa49Srie 35910a4fa49Srie default: 36010a4fa49Srie break; 36110a4fa49Srie } 36210a4fa49Srie } 36310a4fa49Srie 36443d7826aSRod Evans if (threaded) { 36543d7826aSRod Evans /* 36643d7826aSRod Evans * If a version of libc gives us only a subset of the TLS 36743d7826aSRod Evans * interfaces, it's confused and we discard the whole lot. 36843d7826aSRod Evans */ 36943d7826aSRod Evans if ((lcp[CI_TLS_MODADD].lc_un.lc_func && 37043d7826aSRod Evans lcp[CI_TLS_MODREM].lc_un.lc_func && 37143d7826aSRod Evans lcp[CI_TLS_STATMOD].lc_un.lc_func) == NULL) { 37243d7826aSRod Evans lcp[CI_TLS_MODADD].lc_un.lc_func = NULL; 37343d7826aSRod Evans lcp[CI_TLS_MODREM].lc_un.lc_func = NULL; 37443d7826aSRod Evans lcp[CI_TLS_STATMOD].lc_un.lc_func = NULL; 37543d7826aSRod Evans } 37610a4fa49Srie 37743d7826aSRod Evans /* 37843d7826aSRod Evans * Indicate that we're now thread capable. 37943d7826aSRod Evans */ 38043d7826aSRod Evans if ((lml->lm_flags & LML_FLG_RTLDLM) == 0) 38143d7826aSRod Evans rtld_flags |= RT_FL_THREADS; 38210a4fa49Srie } 38310a4fa49Srie 38443d7826aSRod Evans if (entry) 38543d7826aSRod Evans leave(lml, 0); 38610a4fa49Srie } 38710a4fa49Srie 38810a4fa49Srie /* 38910a4fa49Srie * At this point we know we have a set of objects that have been fully analyzed 39010a4fa49Srie * and relocated. Prior to the next major step of running .init sections (ie. 39110a4fa49Srie * running user code), retrieve any RTLDINFO interfaces. 39210a4fa49Srie */ 39310a4fa49Srie int 39410a4fa49Srie rt_get_extern(Lm_list *lml, Rt_map *lmp) 39510a4fa49Srie { 39610a4fa49Srie if (lml->lm_rti) { 397cce0e03bSab Aliste idx; 39810a4fa49Srie Rti_desc *rti; 39910a4fa49Srie 400cce0e03bSab for (ALIST_TRAVERSE(lml->lm_rti, idx, rti)) 40110a4fa49Srie get_lcinterface(rti->rti_lmp, rti->rti_info); 40210a4fa49Srie 40310a4fa49Srie free(lml->lm_rti); 40410a4fa49Srie lml->lm_rti = 0; 40510a4fa49Srie } 40610a4fa49Srie 40710a4fa49Srie /* 40810a4fa49Srie * Perform some sanity checks. If we have TLS requirements we better 40910a4fa49Srie * have the associated external interfaces. 41010a4fa49Srie */ 41143d7826aSRod Evans if (lml->lm_tls && 41243d7826aSRod Evans (lml->lm_lcs[CI_TLS_STATMOD].lc_un.lc_func == NULL)) { 413d326b23bSrie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_TLS_NOSUPPORT), 41410a4fa49Srie NAME(lmp)); 41510a4fa49Srie return (0); 41610a4fa49Srie } 41710a4fa49Srie return (1); 41810a4fa49Srie } 41910a4fa49Srie 42043d7826aSRod Evans /* 42143d7826aSRod Evans * Provide an interface for libc to communicate additional interface 42243d7826aSRod Evans * information. 42343d7826aSRod Evans */ 42443d7826aSRod Evans void 42543d7826aSRod Evans _ld_libc(void *ptr) 42643d7826aSRod Evans { 42743d7826aSRod Evans get_lcinterface(_caller(caller(), CL_EXECDEF), (Lc_interface *)ptr); 42843d7826aSRod Evans } 42943d7826aSRod Evans 43010a4fa49Srie static int bindmask = 0; 43110a4fa49Srie 43210a4fa49Srie int 4338cd45542Sraf rt_bind_guard(int flags) 43410a4fa49Srie { 43510a4fa49Srie int (*fptr)(int); 4368cd45542Sraf int bindflag; 43710a4fa49Srie 43810a4fa49Srie if ((fptr = glcs[CI_BIND_GUARD].lc_un.lc_func) != NULL) { 4398cd45542Sraf return ((*fptr)(flags)); 44010a4fa49Srie } else { 4418cd45542Sraf bindflag = (flags & THR_FLG_RTLD); 44210a4fa49Srie if ((bindflag & bindmask) == 0) { 44310a4fa49Srie bindmask |= bindflag; 44410a4fa49Srie return (1); 44510a4fa49Srie } 44610a4fa49Srie return (0); 44710a4fa49Srie } 44810a4fa49Srie } 44910a4fa49Srie 45010a4fa49Srie int 4518cd45542Sraf rt_bind_clear(int flags) 45210a4fa49Srie { 45310a4fa49Srie int (*fptr)(int); 4548cd45542Sraf int bindflag; 45510a4fa49Srie 45610a4fa49Srie if ((fptr = glcs[CI_BIND_CLEAR].lc_un.lc_func) != NULL) { 4578cd45542Sraf return ((*fptr)(flags)); 45810a4fa49Srie } else { 4598cd45542Sraf bindflag = (flags & THR_FLG_RTLD); 46010a4fa49Srie if (bindflag == 0) 46110a4fa49Srie return (bindmask); 46210a4fa49Srie else { 46310a4fa49Srie bindmask &= ~bindflag; 46410a4fa49Srie return (0); 46510a4fa49Srie } 46610a4fa49Srie } 46710a4fa49Srie } 46810a4fa49Srie 46910a4fa49Srie /* 47010a4fa49Srie * Make sure threads have been initialized. This interface is called once for 47110a4fa49Srie * each link-map list. 47210a4fa49Srie */ 47310a4fa49Srie void 47410a4fa49Srie rt_thr_init(Lm_list *lml) 47510a4fa49Srie { 47610a4fa49Srie void (*fptr)(void); 47710a4fa49Srie 47843d7826aSRod Evans if ((fptr = 47943d7826aSRod Evans (void (*)())lml->lm_lcs[CI_THRINIT].lc_un.lc_func) != NULL) { 48043d7826aSRod Evans lml->lm_lcs[CI_THRINIT].lc_un.lc_func = NULL; 48156deab07SRod Evans leave(NULL, 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 513*2a8d6ebaSRod Evans rt_mutex_lock(Rt_lock *mp) 51410a4fa49Srie { 51510a4fa49Srie return (_lwp_mutex_lock((lwp_mutex_t *)mp)); 51610a4fa49Srie } 51710a4fa49Srie 51810a4fa49Srie int 519*2a8d6ebaSRod Evans rt_mutex_unlock(Rt_lock *mp) 52010a4fa49Srie { 52110a4fa49Srie return (_lwp_mutex_unlock((lwp_mutex_t *)mp)); 52210a4fa49Srie } 52310a4fa49Srie 524*2a8d6ebaSRod Evans /* 525*2a8d6ebaSRod Evans * Test whether we're in a libc critical region. Certain function references, 526*2a8d6ebaSRod Evans * like the "mem*" family, might require binding. Although these functions can 527*2a8d6ebaSRod Evans * safely bind to auxiliary filtees, they should not be captured by auditors. 528*2a8d6ebaSRod Evans */ 529*2a8d6ebaSRod Evans int 530*2a8d6ebaSRod Evans rt_critical() 531*2a8d6ebaSRod Evans { 532*2a8d6ebaSRod Evans int (*fptr)(void); 533*2a8d6ebaSRod Evans 534*2a8d6ebaSRod Evans if ((fptr = glcs[CI_CRITICAL].lc_un.lc_func) != NULL) 535*2a8d6ebaSRod Evans return ((*fptr)()); 536*2a8d6ebaSRod Evans 537*2a8d6ebaSRod Evans return (0); 538*2a8d6ebaSRod Evans } 539*2a8d6ebaSRod 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 { 58110a4fa49Srie #ifdef _LP64 58210a4fa49Srie return (8 * 1024); 58310a4fa49Srie #else 58410a4fa49Srie return (4 * 1024); 58510a4fa49Srie #endif 58610a4fa49Srie } 58710a4fa49Srie 588a574db85Sraf /* 589a574db85Sraf * The following functions are cancellation points in libc. 590a574db85Sraf * They are called from other functions in libc that we extract 591a574db85Sraf * and use directly. We don't do cancellation while we are in 592a574db85Sraf * the dynamic linker, so we redefine these to call the primitive, 593a574db85Sraf * non-cancellation interfaces. 594a574db85Sraf */ 595a574db85Sraf 596a574db85Sraf int 5977257d1b4Sraf close(int fildes) 598a574db85Sraf { 599a574db85Sraf extern int __close(int); 600a574db85Sraf 601a574db85Sraf return (__close(fildes)); 602a574db85Sraf } 603a574db85Sraf 604a574db85Sraf int 6057257d1b4Sraf fcntl(int fildes, int cmd, ...) 606a574db85Sraf { 607a574db85Sraf extern int __fcntl(int, int, ...); 608a574db85Sraf intptr_t arg; 609a574db85Sraf va_list ap; 610a574db85Sraf 611a574db85Sraf va_start(ap, cmd); 612a574db85Sraf arg = va_arg(ap, intptr_t); 613a574db85Sraf va_end(ap); 614a574db85Sraf return (__fcntl(fildes, cmd, arg)); 615a574db85Sraf } 616a574db85Sraf 617a574db85Sraf int 6187257d1b4Sraf open(const char *path, int oflag, ...) 619a574db85Sraf { 620a574db85Sraf extern int __open(const char *, int, ...); 621a574db85Sraf mode_t mode; 622a574db85Sraf va_list ap; 623a574db85Sraf 624a574db85Sraf va_start(ap, oflag); 625a574db85Sraf mode = va_arg(ap, mode_t); 626a574db85Sraf va_end(ap); 627a574db85Sraf return (__open(path, oflag, mode)); 628a574db85Sraf } 629a574db85Sraf 630a574db85Sraf int 6317257d1b4Sraf openat(int fd, const char *path, int oflag, ...) 632a574db85Sraf { 633a574db85Sraf extern int __openat(int, const char *, int, ...); 634a574db85Sraf mode_t mode; 635a574db85Sraf va_list ap; 636a574db85Sraf 637a574db85Sraf va_start(ap, oflag); 638a574db85Sraf mode = va_arg(ap, mode_t); 639a574db85Sraf va_end(ap); 640a574db85Sraf return (__openat(fd, path, oflag, mode)); 641a574db85Sraf } 642a574db85Sraf 643a574db85Sraf ssize_t 6447257d1b4Sraf read(int fd, void *buf, size_t size) 645a574db85Sraf { 646a574db85Sraf extern ssize_t __read(int, void *, size_t); 647a574db85Sraf return (__read(fd, buf, size)); 648a574db85Sraf } 649a574db85Sraf 650a574db85Sraf ssize_t 6517257d1b4Sraf write(int fd, const void *buf, size_t size) 652a574db85Sraf { 653a574db85Sraf extern ssize_t __write(int, const void *, size_t); 654a574db85Sraf return (__write(fd, buf, size)); 655a574db85Sraf } 656