17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 55aefb655Srie * Common Development and Distribution License (the "License"). 65aefb655Srie * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21fb1354edSrie 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright (c) 1988 AT&T 247c478bd9Sstevel@tonic-gate * All Rights Reserved 257c478bd9Sstevel@tonic-gate * 265aefb655Srie * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 277c478bd9Sstevel@tonic-gate * Use is subject to license terms. 287c478bd9Sstevel@tonic-gate */ 297c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate /* 327c478bd9Sstevel@tonic-gate * Utility routines for run-time linker. some are duplicated here from libc 337c478bd9Sstevel@tonic-gate * (with different names) to avoid name space collisions. 347c478bd9Sstevel@tonic-gate */ 357c478bd9Sstevel@tonic-gate #include "_synonyms.h" 367c478bd9Sstevel@tonic-gate #include <stdio.h> 377c478bd9Sstevel@tonic-gate #include <sys/types.h> 387c478bd9Sstevel@tonic-gate #include <sys/mman.h> 397c478bd9Sstevel@tonic-gate #include <sys/lwp.h> 407c478bd9Sstevel@tonic-gate #include <sys/debug.h> 417c478bd9Sstevel@tonic-gate #include <stdarg.h> 427c478bd9Sstevel@tonic-gate #include <fcntl.h> 437c478bd9Sstevel@tonic-gate #include <string.h> 447c478bd9Sstevel@tonic-gate #include <ctype.h> 457c478bd9Sstevel@tonic-gate #include <dlfcn.h> 467c478bd9Sstevel@tonic-gate #include <unistd.h> 477c478bd9Sstevel@tonic-gate #include <stdlib.h> 487c478bd9Sstevel@tonic-gate #include <sys/auxv.h> 495aefb655Srie #include <debug.h> 505aefb655Srie #include <conv.h> 517c478bd9Sstevel@tonic-gate #include "_rtld.h" 527c478bd9Sstevel@tonic-gate #include "_audit.h" 53*10a4fa49Srie #include "_elf.h" 547c478bd9Sstevel@tonic-gate #include "msg.h" 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate static int ld_flags_env(const char *, Word *, Word *, uint_t, int); 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate /* 597c478bd9Sstevel@tonic-gate * All error messages go through eprintf(). During process initialization these 607c478bd9Sstevel@tonic-gate * messages should be directed to the standard error, however once control has 617c478bd9Sstevel@tonic-gate * been passed to the applications code these messages should be stored in an 627c478bd9Sstevel@tonic-gate * internal buffer for use with dlerror(). Note, fatal error conditions that 637c478bd9Sstevel@tonic-gate * may occur while running the application will still cause a standard error 647c478bd9Sstevel@tonic-gate * message, see rtldexit() in this file for details. 657c478bd9Sstevel@tonic-gate * The `application' flag serves to indicate the transition between process 667c478bd9Sstevel@tonic-gate * initialization and when the applications code is running. 677c478bd9Sstevel@tonic-gate */ 687c478bd9Sstevel@tonic-gate 697c478bd9Sstevel@tonic-gate /* 707c478bd9Sstevel@tonic-gate * Null function used as place where a debugger can set a breakpoint. 717c478bd9Sstevel@tonic-gate */ 727c478bd9Sstevel@tonic-gate void 735aefb655Srie rtld_db_dlactivity(Lm_list *lml) 747c478bd9Sstevel@tonic-gate { 755aefb655Srie DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent, 765aefb655Srie r_debug.rtd_rdebug.r_state)); 777c478bd9Sstevel@tonic-gate } 787c478bd9Sstevel@tonic-gate 797c478bd9Sstevel@tonic-gate /* 807c478bd9Sstevel@tonic-gate * Null function used as place where debugger can set a pre .init 817c478bd9Sstevel@tonic-gate * processing breakpoint. 827c478bd9Sstevel@tonic-gate */ 837c478bd9Sstevel@tonic-gate void 845aefb655Srie rtld_db_preinit(Lm_list *lml) 857c478bd9Sstevel@tonic-gate { 865aefb655Srie DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent, 875aefb655Srie r_debug.rtd_rdebug.r_state)); 887c478bd9Sstevel@tonic-gate } 897c478bd9Sstevel@tonic-gate 907c478bd9Sstevel@tonic-gate /* 917c478bd9Sstevel@tonic-gate * Null function used as place where debugger can set a post .init 927c478bd9Sstevel@tonic-gate * processing breakpoint. 937c478bd9Sstevel@tonic-gate */ 947c478bd9Sstevel@tonic-gate void 955aefb655Srie rtld_db_postinit(Lm_list *lml) 967c478bd9Sstevel@tonic-gate { 975aefb655Srie DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent, 985aefb655Srie r_debug.rtd_rdebug.r_state)); 997c478bd9Sstevel@tonic-gate } 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate /* 1027c478bd9Sstevel@tonic-gate * Debugger Event Notification 1037c478bd9Sstevel@tonic-gate * 1047c478bd9Sstevel@tonic-gate * This function centralizes all debugger event notification (ala rtld_db). 1057c478bd9Sstevel@tonic-gate * 1067c478bd9Sstevel@tonic-gate * There's a simple intent, focused on insuring the primary link-map control 1077c478bd9Sstevel@tonic-gate * list (or each link-map list) is consistent, and the indication that objects 1087c478bd9Sstevel@tonic-gate * have been added or deleted from this list. Although an RD_ADD and RD_DELETE 1097c478bd9Sstevel@tonic-gate * event are posted for each of these, most debuggers don't care, as their 1107c478bd9Sstevel@tonic-gate * view is that these events simply convey an "inconsistent" state. 1117c478bd9Sstevel@tonic-gate * 1127c478bd9Sstevel@tonic-gate * We also don't want to trigger multiple RD_ADD/RD_DELETE events any time we 1137c478bd9Sstevel@tonic-gate * enter ld.so.1. 1147c478bd9Sstevel@tonic-gate * 1157c478bd9Sstevel@tonic-gate * With auditors, we may be in the process of relocating a collection of 1167c478bd9Sstevel@tonic-gate * objects, and will leave() ld.so.1 to call the auditor. At this point we 1177c478bd9Sstevel@tonic-gate * must indicate an RD_CONSISTENT event, but librtld_db will not report an 1187c478bd9Sstevel@tonic-gate * object to the debuggers until relocation processing has been completed on it. 1197c478bd9Sstevel@tonic-gate * To allow for the collection of these objects that are pending relocation, an 1207c478bd9Sstevel@tonic-gate * RD_ADD event is set after completing a series of relocations on the primary 1217c478bd9Sstevel@tonic-gate * link-map control list. 1227c478bd9Sstevel@tonic-gate * 1237c478bd9Sstevel@tonic-gate * Set an RD_ADD/RD_DELETE event and indicate that an RD_CONSISTENT event is 1247c478bd9Sstevel@tonic-gate * required later (LML_FLG_DBNOTIF): 1257c478bd9Sstevel@tonic-gate * 1267c478bd9Sstevel@tonic-gate * i the first time we add or delete an object to the primary link-map 1277c478bd9Sstevel@tonic-gate * control list. 1287c478bd9Sstevel@tonic-gate * ii the first time we move a secondary link-map control list to the primary 1297c478bd9Sstevel@tonic-gate * link-map control list (effectively, this is like adding a group of 1307c478bd9Sstevel@tonic-gate * objects to the primary link-map control list). 1317c478bd9Sstevel@tonic-gate * iii the first time we relocate a series of objects on the primary link-map 1327c478bd9Sstevel@tonic-gate * control list. 1337c478bd9Sstevel@tonic-gate * 1347c478bd9Sstevel@tonic-gate * Set an RD_CONSISTENT event when it is required (LML_FLG_DBNOTIF is set) and 1357c478bd9Sstevel@tonic-gate * 1367c478bd9Sstevel@tonic-gate * i each time we leave the runtime linker. 1377c478bd9Sstevel@tonic-gate */ 1387c478bd9Sstevel@tonic-gate void 1397c478bd9Sstevel@tonic-gate rd_event(Lm_list *lml, rd_event_e event, r_state_e state) 1407c478bd9Sstevel@tonic-gate { 141*10a4fa49Srie void (*fptr)(Lm_list *); 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate switch (event) { 1447c478bd9Sstevel@tonic-gate case RD_PREINIT: 1457c478bd9Sstevel@tonic-gate fptr = rtld_db_preinit; 1467c478bd9Sstevel@tonic-gate break; 1477c478bd9Sstevel@tonic-gate case RD_POSTINIT: 1487c478bd9Sstevel@tonic-gate fptr = rtld_db_postinit; 1497c478bd9Sstevel@tonic-gate break; 1507c478bd9Sstevel@tonic-gate case RD_DLACTIVITY: 1517c478bd9Sstevel@tonic-gate switch (state) { 1527c478bd9Sstevel@tonic-gate case RT_CONSISTENT: 1537c478bd9Sstevel@tonic-gate lml->lm_flags &= ~LML_FLG_DBNOTIF; 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate /* 1567c478bd9Sstevel@tonic-gate * Do we need to send a notification? 1577c478bd9Sstevel@tonic-gate */ 1587c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_DBNOTIF) == 0) 1597c478bd9Sstevel@tonic-gate return; 1607c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_DBNOTIF; 1617c478bd9Sstevel@tonic-gate break; 1627c478bd9Sstevel@tonic-gate case RT_ADD: 1637c478bd9Sstevel@tonic-gate case RT_DELETE: 1647c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_DBNOTIF; 1657c478bd9Sstevel@tonic-gate 1667c478bd9Sstevel@tonic-gate /* 1677c478bd9Sstevel@tonic-gate * If we are already in an inconsistent state, no 1687c478bd9Sstevel@tonic-gate * notification is required. 1697c478bd9Sstevel@tonic-gate */ 1707c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_DBNOTIF) 1717c478bd9Sstevel@tonic-gate return; 1727c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_DBNOTIF; 1737c478bd9Sstevel@tonic-gate break; 1747c478bd9Sstevel@tonic-gate }; 1757c478bd9Sstevel@tonic-gate fptr = rtld_db_dlactivity; 1767c478bd9Sstevel@tonic-gate break; 1777c478bd9Sstevel@tonic-gate default: 1787c478bd9Sstevel@tonic-gate /* 1797c478bd9Sstevel@tonic-gate * RD_NONE - do nothing 1807c478bd9Sstevel@tonic-gate */ 1817c478bd9Sstevel@tonic-gate break; 1827c478bd9Sstevel@tonic-gate }; 1837c478bd9Sstevel@tonic-gate 1847c478bd9Sstevel@tonic-gate /* 1857c478bd9Sstevel@tonic-gate * Set event state and call 'notification' function. 1867c478bd9Sstevel@tonic-gate * 1877c478bd9Sstevel@tonic-gate * The debugging clients have previously been told about these 1887c478bd9Sstevel@tonic-gate * notification functions and have set breakpoints on them if they 1897c478bd9Sstevel@tonic-gate * are interested in the notification. 1907c478bd9Sstevel@tonic-gate */ 1917c478bd9Sstevel@tonic-gate r_debug.rtd_rdebug.r_state = state; 1927c478bd9Sstevel@tonic-gate r_debug.rtd_rdebug.r_rdevent = event; 1935aefb655Srie fptr(lml); 1947c478bd9Sstevel@tonic-gate r_debug.rtd_rdebug.r_rdevent = RD_NONE; 1957c478bd9Sstevel@tonic-gate } 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate #if defined(sparc) || defined(i386) || defined(__amd64) 1987c478bd9Sstevel@tonic-gate /* 1997c478bd9Sstevel@tonic-gate * Stack Cleanup. 2007c478bd9Sstevel@tonic-gate * 2017c478bd9Sstevel@tonic-gate * This function is invoked to 'remove' arguments that were passed in on the 2027c478bd9Sstevel@tonic-gate * stack. This is most likely if ld.so.1 was invoked directly. In that case 2037c478bd9Sstevel@tonic-gate * we want to remove ld.so.1 as well as it's arguments from the argv[] array. 2047c478bd9Sstevel@tonic-gate * Which means we then need to slide everything above it on the stack down 2057c478bd9Sstevel@tonic-gate * accordingly. 2067c478bd9Sstevel@tonic-gate * 2077c478bd9Sstevel@tonic-gate * While the stack layout is platform specific - it just so happens that x86, 20841072f3cSrie * sparc, sparcv9, and amd64 all share the following initial stack layout. 2097c478bd9Sstevel@tonic-gate * 2107c478bd9Sstevel@tonic-gate * !_______________________! high addresses 2117c478bd9Sstevel@tonic-gate * ! ! 2127c478bd9Sstevel@tonic-gate * ! Information ! 2137c478bd9Sstevel@tonic-gate * ! Block ! 2147c478bd9Sstevel@tonic-gate * ! (size varies) ! 2157c478bd9Sstevel@tonic-gate * !_______________________! 2167c478bd9Sstevel@tonic-gate * ! 0 word ! 2177c478bd9Sstevel@tonic-gate * !_______________________! 2187c478bd9Sstevel@tonic-gate * ! Auxiliary ! 2197c478bd9Sstevel@tonic-gate * ! vector ! 2207c478bd9Sstevel@tonic-gate * ! 2 word entries ! 2217c478bd9Sstevel@tonic-gate * ! ! 2227c478bd9Sstevel@tonic-gate * !_______________________! 2237c478bd9Sstevel@tonic-gate * ! 0 word ! 2247c478bd9Sstevel@tonic-gate * !_______________________! 2257c478bd9Sstevel@tonic-gate * ! Environment ! 2267c478bd9Sstevel@tonic-gate * ! pointers ! 2277c478bd9Sstevel@tonic-gate * ! ... ! 2287c478bd9Sstevel@tonic-gate * ! (one word each) ! 2297c478bd9Sstevel@tonic-gate * !_______________________! 2307c478bd9Sstevel@tonic-gate * ! 0 word ! 2317c478bd9Sstevel@tonic-gate * !_______________________! 2327c478bd9Sstevel@tonic-gate * ! Argument ! low addresses 2337c478bd9Sstevel@tonic-gate * ! pointers ! 2347c478bd9Sstevel@tonic-gate * ! Argc words ! 2357c478bd9Sstevel@tonic-gate * !_______________________! 2367c478bd9Sstevel@tonic-gate * ! ! 2377c478bd9Sstevel@tonic-gate * ! Argc ! 2387c478bd9Sstevel@tonic-gate * !_______________________! 2397c478bd9Sstevel@tonic-gate * ! ... ! 2407c478bd9Sstevel@tonic-gate * 2417c478bd9Sstevel@tonic-gate */ 2427c478bd9Sstevel@tonic-gate static void 24341072f3cSrie stack_cleanup(char **argv, char ***envp, auxv_t **auxv, int rmcnt) 2447c478bd9Sstevel@tonic-gate { 24541072f3cSrie int ndx; 2467c478bd9Sstevel@tonic-gate long *argc; 24741072f3cSrie char **oargv, **nargv; 24841072f3cSrie char **oenvp, **nenvp; 24941072f3cSrie auxv_t *oauxv, *nauxv; 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate /* 25241072f3cSrie * Slide ARGV[] and update argc. The argv pointer remains the same, 25341072f3cSrie * however slide the applications arguments over the arguments to 25441072f3cSrie * ld.so.1. 2557c478bd9Sstevel@tonic-gate */ 25641072f3cSrie nargv = &argv[0]; 25741072f3cSrie oargv = &argv[rmcnt]; 25841072f3cSrie 25941072f3cSrie for (ndx = 0; oargv[ndx]; ndx++) 26041072f3cSrie nargv[ndx] = oargv[ndx]; 26141072f3cSrie nargv[ndx] = oargv[ndx]; 26241072f3cSrie 26341072f3cSrie argc = (long *)((uintptr_t)argv - sizeof (long *)); 2647c478bd9Sstevel@tonic-gate *argc -= rmcnt; 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate /* 26741072f3cSrie * Slide ENVP[], and update the environment array pointer. 2687c478bd9Sstevel@tonic-gate */ 26941072f3cSrie ndx++; 27041072f3cSrie nenvp = &nargv[ndx]; 27141072f3cSrie oenvp = &oargv[ndx]; 27241072f3cSrie *envp = nenvp; 27341072f3cSrie 27441072f3cSrie for (ndx = 0; oenvp[ndx]; ndx++) 27541072f3cSrie nenvp[ndx] = oenvp[ndx]; 27641072f3cSrie nenvp[ndx] = oenvp[ndx]; 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate /* 27941072f3cSrie * Slide AUXV[], and update the aux vector pointer. 2807c478bd9Sstevel@tonic-gate */ 28141072f3cSrie ndx++; 28241072f3cSrie nauxv = (auxv_t *)&nenvp[ndx]; 28341072f3cSrie oauxv = (auxv_t *)&oenvp[ndx]; 28441072f3cSrie *auxv = nauxv; 28541072f3cSrie 28641072f3cSrie for (ndx = 0; (oauxv[ndx].a_type != AT_NULL); ndx++) 28741072f3cSrie nauxv[ndx] = oauxv[ndx]; 28841072f3cSrie nauxv[ndx] = oauxv[ndx]; 2897c478bd9Sstevel@tonic-gate } 2907c478bd9Sstevel@tonic-gate #else 2917c478bd9Sstevel@tonic-gate /* 2927c478bd9Sstevel@tonic-gate * Verify that the above routine is appropriate for any new platforms. 2937c478bd9Sstevel@tonic-gate */ 2947c478bd9Sstevel@tonic-gate #error unsupported architecture! 2957c478bd9Sstevel@tonic-gate #endif 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate /* 29841072f3cSrie * The only command line argument recognized is -e, followed by a runtime 29941072f3cSrie * linker environment variable. 3007c478bd9Sstevel@tonic-gate */ 3017c478bd9Sstevel@tonic-gate int 30241072f3cSrie rtld_getopt(char **argv, char ***envp, auxv_t **auxv, Word *lmflags, 30341072f3cSrie Word *lmtflags, int aout) 3047c478bd9Sstevel@tonic-gate { 30541072f3cSrie int ndx; 3067c478bd9Sstevel@tonic-gate 30741072f3cSrie for (ndx = 1; argv[ndx]; ndx++) { 3087c478bd9Sstevel@tonic-gate char *str; 3097c478bd9Sstevel@tonic-gate 31041072f3cSrie if (argv[ndx][0] != '-') 3117c478bd9Sstevel@tonic-gate break; 3127c478bd9Sstevel@tonic-gate 31341072f3cSrie if (argv[ndx][1] == '\0') { 31441072f3cSrie ndx++; 3157c478bd9Sstevel@tonic-gate break; 3167c478bd9Sstevel@tonic-gate } 3177c478bd9Sstevel@tonic-gate 31841072f3cSrie if (argv[ndx][1] != 'e') 31941072f3cSrie return (1); 3207c478bd9Sstevel@tonic-gate 32141072f3cSrie if (argv[ndx][2] == '\0') { 32241072f3cSrie ndx++; 32341072f3cSrie if (argv[ndx] == NULL) 32441072f3cSrie return (1); 32541072f3cSrie str = argv[ndx]; 3267c478bd9Sstevel@tonic-gate } else 32741072f3cSrie str = &argv[ndx][2]; 3287c478bd9Sstevel@tonic-gate 32941072f3cSrie /* 33041072f3cSrie * If the environment variable starts with LD_, strip the LD_. 33141072f3cSrie * Otherwise, take things as is. 33241072f3cSrie */ 33341072f3cSrie if ((str[0] == 'L') && (str[1] == 'D') && (str[2] == '_') && 33441072f3cSrie (str[3] != '\0')) 33541072f3cSrie str += 3; 3367c478bd9Sstevel@tonic-gate if (ld_flags_env(str, lmflags, lmtflags, 0, aout) == 1) 3377c478bd9Sstevel@tonic-gate return (1); 3387c478bd9Sstevel@tonic-gate } 3397c478bd9Sstevel@tonic-gate 34041072f3cSrie /* 34141072f3cSrie * Make sure an object file has been specified. 34241072f3cSrie */ 34341072f3cSrie if (argv[ndx] == 0) 3447c478bd9Sstevel@tonic-gate return (1); 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate /* 3477c478bd9Sstevel@tonic-gate * Having gotten the arguments, clean ourselves off of the stack. 3487c478bd9Sstevel@tonic-gate */ 34941072f3cSrie stack_cleanup(argv, envp, auxv, ndx); 3507c478bd9Sstevel@tonic-gate return (0); 3517c478bd9Sstevel@tonic-gate } 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate /* 3547c478bd9Sstevel@tonic-gate * Compare function for FullpathNode AVL tree. 3557c478bd9Sstevel@tonic-gate */ 3567c478bd9Sstevel@tonic-gate static int 3577c478bd9Sstevel@tonic-gate fpavl_compare(const void * n1, const void * n2) 3587c478bd9Sstevel@tonic-gate { 3597c478bd9Sstevel@tonic-gate uint_t hash1, hash2; 3607c478bd9Sstevel@tonic-gate const char *st1, *st2; 3617c478bd9Sstevel@tonic-gate int rc; 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate hash1 = ((FullpathNode *)n1)->fpn_hash; 3647c478bd9Sstevel@tonic-gate hash2 = ((FullpathNode *)n2)->fpn_hash; 3657c478bd9Sstevel@tonic-gate 3667c478bd9Sstevel@tonic-gate if (hash1 > hash2) 3677c478bd9Sstevel@tonic-gate return (1); 3687c478bd9Sstevel@tonic-gate if (hash1 < hash2) 3697c478bd9Sstevel@tonic-gate return (-1); 3707c478bd9Sstevel@tonic-gate 3717c478bd9Sstevel@tonic-gate st1 = ((FullpathNode *)n1)->fpn_name; 3727c478bd9Sstevel@tonic-gate st2 = ((FullpathNode *)n2)->fpn_name; 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate rc = strcmp(st1, st2); 3757c478bd9Sstevel@tonic-gate if (rc > 0) 3767c478bd9Sstevel@tonic-gate return (1); 3777c478bd9Sstevel@tonic-gate if (rc < 0) 3787c478bd9Sstevel@tonic-gate return (-1); 3797c478bd9Sstevel@tonic-gate return (0); 3807c478bd9Sstevel@tonic-gate } 3817c478bd9Sstevel@tonic-gate 3827c478bd9Sstevel@tonic-gate 3837c478bd9Sstevel@tonic-gate /* 38424a6229eSrie * Determine if a given pathname has already been loaded in the AVL tree. 3857c478bd9Sstevel@tonic-gate * If the pathname does not exist in the AVL tree, the next insertion point 3867c478bd9Sstevel@tonic-gate * is deposited in "where". This value can be used by fpavl_insert() to 3877c478bd9Sstevel@tonic-gate * expedite the insertion. 3887c478bd9Sstevel@tonic-gate */ 3897c478bd9Sstevel@tonic-gate Rt_map * 3907c478bd9Sstevel@tonic-gate fpavl_loaded(Lm_list *lml, const char *name, avl_index_t *where) 3917c478bd9Sstevel@tonic-gate { 3927c478bd9Sstevel@tonic-gate FullpathNode fpn, *fpnp; 3937c478bd9Sstevel@tonic-gate avl_tree_t *avlt; 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate /* 3967c478bd9Sstevel@tonic-gate * Create the avl tree if required. 3977c478bd9Sstevel@tonic-gate */ 3987c478bd9Sstevel@tonic-gate if ((avlt = lml->lm_fpavl) == NULL) { 3997c478bd9Sstevel@tonic-gate if ((avlt = calloc(sizeof (avl_tree_t), 1)) == 0) 4007c478bd9Sstevel@tonic-gate return (0); 4017c478bd9Sstevel@tonic-gate avl_create(avlt, fpavl_compare, sizeof (FullpathNode), 4027c478bd9Sstevel@tonic-gate SGSOFFSETOF(FullpathNode, fpn_avl)); 4037c478bd9Sstevel@tonic-gate lml->lm_fpavl = avlt; 4047c478bd9Sstevel@tonic-gate } 4057c478bd9Sstevel@tonic-gate 4067c478bd9Sstevel@tonic-gate fpn.fpn_name = name; 4077c478bd9Sstevel@tonic-gate fpn.fpn_hash = sgs_str_hash(name); 4087c478bd9Sstevel@tonic-gate 4097c478bd9Sstevel@tonic-gate if ((fpnp = avl_find(lml->lm_fpavl, &fpn, where)) == NULL) 4107c478bd9Sstevel@tonic-gate return (NULL); 4117c478bd9Sstevel@tonic-gate 4127c478bd9Sstevel@tonic-gate return (fpnp->fpn_lmp); 4137c478bd9Sstevel@tonic-gate } 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate /* 41724a6229eSrie * Insert a name into the FullpathNode AVL tree for the link-map list. The 41824a6229eSrie * objects NAME() is the path that would have originally been searched for, and 41924a6229eSrie * is therefore the name to associate with any "where" value. If the object has 4207c478bd9Sstevel@tonic-gate * a different PATHNAME(), perhaps because it has resolved to a different file 4217c478bd9Sstevel@tonic-gate * (see fullpath), then this name is recorded also. See load_file(). 4227c478bd9Sstevel@tonic-gate */ 4237c478bd9Sstevel@tonic-gate int 4247c478bd9Sstevel@tonic-gate fpavl_insert(Lm_list *lml, Rt_map *lmp, const char *name, avl_index_t where) 4257c478bd9Sstevel@tonic-gate { 4267c478bd9Sstevel@tonic-gate FullpathNode *fpnp; 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate if (where == 0) { 4297c478bd9Sstevel@tonic-gate /* LINTED */ 4307c478bd9Sstevel@tonic-gate Rt_map *_lmp = fpavl_loaded(lml, name, &where); 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate /* 4337c478bd9Sstevel@tonic-gate * We better not get a hit now, we do not want duplicates in 4347c478bd9Sstevel@tonic-gate * the tree. 4357c478bd9Sstevel@tonic-gate */ 4367c478bd9Sstevel@tonic-gate ASSERT(_lmp == 0); 4377c478bd9Sstevel@tonic-gate } 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate /* 4407c478bd9Sstevel@tonic-gate * Insert new node in tree 4417c478bd9Sstevel@tonic-gate */ 4427c478bd9Sstevel@tonic-gate if ((fpnp = calloc(sizeof (FullpathNode), 1)) == 0) 4437c478bd9Sstevel@tonic-gate return (0); 4447c478bd9Sstevel@tonic-gate 4457c478bd9Sstevel@tonic-gate fpnp->fpn_name = name; 4467c478bd9Sstevel@tonic-gate fpnp->fpn_hash = sgs_str_hash(name); 4477c478bd9Sstevel@tonic-gate fpnp->fpn_lmp = lmp; 4487c478bd9Sstevel@tonic-gate 4497c478bd9Sstevel@tonic-gate if (alist_append(&FPNODE(lmp), &fpnp, sizeof (FullpathNode *), 4507c478bd9Sstevel@tonic-gate AL_CNT_FPNODE) == 0) { 4517c478bd9Sstevel@tonic-gate free(fpnp); 4527c478bd9Sstevel@tonic-gate return (0); 4537c478bd9Sstevel@tonic-gate } 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate ASSERT(lml->lm_fpavl != NULL); 4567c478bd9Sstevel@tonic-gate avl_insert(lml->lm_fpavl, fpnp, where); 4577c478bd9Sstevel@tonic-gate return (1); 4587c478bd9Sstevel@tonic-gate } 4597c478bd9Sstevel@tonic-gate 4607c478bd9Sstevel@tonic-gate /* 46124a6229eSrie * Remove an object from the Fullpath AVL tree. Note, this is called *before* 4627c478bd9Sstevel@tonic-gate * the objects link-map is torn down (remove_so), which is where any NAME() and 4637c478bd9Sstevel@tonic-gate * PATHNAME() strings will be deallocated. 4647c478bd9Sstevel@tonic-gate */ 4657c478bd9Sstevel@tonic-gate void 4667c478bd9Sstevel@tonic-gate fpavl_remove(Rt_map *lmp) 4677c478bd9Sstevel@tonic-gate { 4687c478bd9Sstevel@tonic-gate FullpathNode **fpnpp; 4697c478bd9Sstevel@tonic-gate Aliste off; 4707c478bd9Sstevel@tonic-gate 4717c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(FPNODE(lmp), off, fpnpp)) { 4727c478bd9Sstevel@tonic-gate FullpathNode *fpnp = *fpnpp; 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate avl_remove(LIST(lmp)->lm_fpavl, fpnp); 4757c478bd9Sstevel@tonic-gate free(fpnp); 4767c478bd9Sstevel@tonic-gate } 4777c478bd9Sstevel@tonic-gate free(FPNODE(lmp)); 4787c478bd9Sstevel@tonic-gate FPNODE(lmp) = 0; 4797c478bd9Sstevel@tonic-gate } 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate 4827c478bd9Sstevel@tonic-gate /* 4837c478bd9Sstevel@tonic-gate * Prior to calling an object, either via a .plt or through dlsym(), make sure 4847c478bd9Sstevel@tonic-gate * its .init has fired. Through topological sorting, ld.so.1 attempts to fire 4857c478bd9Sstevel@tonic-gate * init's in the correct order, however, this order is typically based on needed 4867c478bd9Sstevel@tonic-gate * dependencies and non-lazy relocation bindings. Lazy relocations (.plts) can 4877c478bd9Sstevel@tonic-gate * still occur and result in bindings that were not captured during topological 4887c478bd9Sstevel@tonic-gate * sorting. This routine compensates for this lack of binding information, and 4897c478bd9Sstevel@tonic-gate * provides for dynamic .init firing. 4907c478bd9Sstevel@tonic-gate */ 4917c478bd9Sstevel@tonic-gate void 4927c478bd9Sstevel@tonic-gate is_dep_init(Rt_map * dlmp, Rt_map * clmp) 4937c478bd9Sstevel@tonic-gate { 4947c478bd9Sstevel@tonic-gate Rt_map ** tobj; 4957c478bd9Sstevel@tonic-gate 4967c478bd9Sstevel@tonic-gate /* 4977c478bd9Sstevel@tonic-gate * If the caller is an auditor, and the destination isn't, then don't 4987c478bd9Sstevel@tonic-gate * run any .inits (see comments in load_completion()). 4997c478bd9Sstevel@tonic-gate */ 5007c478bd9Sstevel@tonic-gate if ((LIST(clmp)->lm_flags & LML_FLG_NOAUDIT) && 5017c478bd9Sstevel@tonic-gate (LIST(clmp) != LIST(dlmp))) 5027c478bd9Sstevel@tonic-gate return; 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate if ((dlmp == clmp) || (rtld_flags & (RT_FL_BREADTH | RT_FL_INITFIRST))) 5057c478bd9Sstevel@tonic-gate return; 5067c478bd9Sstevel@tonic-gate 5077c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITDONE)) == 5087c478bd9Sstevel@tonic-gate (FLG_RT_RELOCED | FLG_RT_INITDONE)) 5097c478bd9Sstevel@tonic-gate return; 5107c478bd9Sstevel@tonic-gate 5117c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITCALL)) == 5127c478bd9Sstevel@tonic-gate (FLG_RT_RELOCED | FLG_RT_INITCALL)) { 5135aefb655Srie DBG_CALL(Dbg_util_no_init(dlmp)); 5147c478bd9Sstevel@tonic-gate return; 5157c478bd9Sstevel@tonic-gate } 5167c478bd9Sstevel@tonic-gate 5177c478bd9Sstevel@tonic-gate if ((tobj = calloc(2, sizeof (Rt_map *))) != NULL) { 5187c478bd9Sstevel@tonic-gate tobj[0] = dlmp; 5197c478bd9Sstevel@tonic-gate call_init(tobj, DBG_INIT_DYN); 5207c478bd9Sstevel@tonic-gate } 5217c478bd9Sstevel@tonic-gate } 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate /* 5247c478bd9Sstevel@tonic-gate * In a threaded environment insure the thread responsible for loading an object 5257c478bd9Sstevel@tonic-gate * has completed .init processing for that object before any new thread is 5267c478bd9Sstevel@tonic-gate * allowed to access the object. This check is only valid with libthread 5277c478bd9Sstevel@tonic-gate * TI_VERSION 2, where ld.so.1 implements locking through low level mutexes. 5287c478bd9Sstevel@tonic-gate * 5297c478bd9Sstevel@tonic-gate * When a new link-map is created, the thread that causes it to be loaded is 5307c478bd9Sstevel@tonic-gate * identified by THREADID(dlmp). Compare this with the current thread to 5317c478bd9Sstevel@tonic-gate * determine if it must be blocked. 5327c478bd9Sstevel@tonic-gate * 5337c478bd9Sstevel@tonic-gate * NOTE, there are a number of instances (typically only for .plt processing) 5347c478bd9Sstevel@tonic-gate * where we must skip this test: 5357c478bd9Sstevel@tonic-gate * 5367c478bd9Sstevel@tonic-gate * . any thread id of 0 - threads that call thr_exit() may be in this state 5377c478bd9Sstevel@tonic-gate * thus we can't deduce what tid they used to be. Also some of the 5387c478bd9Sstevel@tonic-gate * lib/libthread worker threads have this id and must bind (to themselves 5397c478bd9Sstevel@tonic-gate * or libc) for libthread to function. 5407c478bd9Sstevel@tonic-gate * 5417c478bd9Sstevel@tonic-gate * . libthread itself binds to libc, and as libthread is INITFIRST 5427c478bd9Sstevel@tonic-gate * libc's .init can't have fired yet. Luckly libc's .init is not required 5437c478bd9Sstevel@tonic-gate * by libthreads binding. 5447c478bd9Sstevel@tonic-gate * 5457c478bd9Sstevel@tonic-gate * . if the caller is an auditor, and the destination isn't, then don't 5467c478bd9Sstevel@tonic-gate * block (see comments in load_completion()). 5477c478bd9Sstevel@tonic-gate */ 5487c478bd9Sstevel@tonic-gate void 5497c478bd9Sstevel@tonic-gate is_dep_ready(Rt_map * dlmp, Rt_map * clmp, int what) 5507c478bd9Sstevel@tonic-gate { 5517c478bd9Sstevel@tonic-gate thread_t tid; 5527c478bd9Sstevel@tonic-gate 5537c478bd9Sstevel@tonic-gate if ((LIST(clmp)->lm_flags & LML_FLG_NOAUDIT) && 5547c478bd9Sstevel@tonic-gate (LIST(clmp) != LIST(dlmp))) 5557c478bd9Sstevel@tonic-gate return; 5567c478bd9Sstevel@tonic-gate 5577c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_CONCUR) && 5587c478bd9Sstevel@tonic-gate ((FLAGS(dlmp) & FLG_RT_INITDONE) == 0) && 5597c478bd9Sstevel@tonic-gate ((FLAGS(clmp) & FLG_RT_INITFRST) == 0) && 5607c478bd9Sstevel@tonic-gate ((tid = rt_thr_self()) != 0) && (THREADID(dlmp) != tid)) { 5617c478bd9Sstevel@tonic-gate while ((FLAGS(dlmp) & FLG_RT_INITDONE) == 0) { 5627c478bd9Sstevel@tonic-gate FLAGS1(dlmp) |= FL1_RT_INITWAIT; 5635aefb655Srie DBG_CALL(Dbg_util_wait(clmp, dlmp, what)); 5647c478bd9Sstevel@tonic-gate (void) rt_cond_wait(CONDVAR(dlmp), &rtldlock); 5657c478bd9Sstevel@tonic-gate } 5667c478bd9Sstevel@tonic-gate } 5677c478bd9Sstevel@tonic-gate } 5687c478bd9Sstevel@tonic-gate 5697c478bd9Sstevel@tonic-gate /* 5707c478bd9Sstevel@tonic-gate * Execute .{preinit|init|fini}array sections 5717c478bd9Sstevel@tonic-gate */ 5727c478bd9Sstevel@tonic-gate void 5735aefb655Srie call_array(Addr *array, uint_t arraysz, Rt_map *lmp, Word shtype) 5747c478bd9Sstevel@tonic-gate { 5755aefb655Srie int start, stop, incr, ndx; 5767c478bd9Sstevel@tonic-gate uint_t arraycnt = (uint_t)(arraysz / sizeof (Addr)); 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate if (array == NULL) 5797c478bd9Sstevel@tonic-gate return; 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate /* 5827c478bd9Sstevel@tonic-gate * initarray & preinitarray are walked from beginning to end - while 5837c478bd9Sstevel@tonic-gate * finiarray is walked from end to beginning. 5847c478bd9Sstevel@tonic-gate */ 5857c478bd9Sstevel@tonic-gate if (shtype == SHT_FINI_ARRAY) { 5867c478bd9Sstevel@tonic-gate start = arraycnt - 1; 5877c478bd9Sstevel@tonic-gate stop = incr = -1; 5887c478bd9Sstevel@tonic-gate } else { 5897c478bd9Sstevel@tonic-gate start = 0; 5907c478bd9Sstevel@tonic-gate stop = arraycnt; 5917c478bd9Sstevel@tonic-gate incr = 1; 5927c478bd9Sstevel@tonic-gate } 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate /* 5957c478bd9Sstevel@tonic-gate * Call the .*array[] entries 5967c478bd9Sstevel@tonic-gate */ 5975aefb655Srie for (ndx = start; ndx != stop; ndx += incr) { 598*10a4fa49Srie void (*fptr)(void) = (void(*)())array[ndx]; 5997c478bd9Sstevel@tonic-gate 6005aefb655Srie DBG_CALL(Dbg_util_call_array(lmp, (void *)fptr, ndx, shtype)); 6017c478bd9Sstevel@tonic-gate 6027c478bd9Sstevel@tonic-gate leave(LIST(lmp)); 6037c478bd9Sstevel@tonic-gate (*fptr)(); 6047c478bd9Sstevel@tonic-gate (void) enter(); 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate } 6077c478bd9Sstevel@tonic-gate 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate /* 6107c478bd9Sstevel@tonic-gate * Execute any .init sections. These are passed to us in an lmp array which 6117c478bd9Sstevel@tonic-gate * (by default) will have been sorted. 6127c478bd9Sstevel@tonic-gate */ 6137c478bd9Sstevel@tonic-gate void 6147c478bd9Sstevel@tonic-gate call_init(Rt_map ** tobj, int flag) 6157c478bd9Sstevel@tonic-gate { 6167c478bd9Sstevel@tonic-gate Rt_map ** _tobj, ** _nobj; 6177c478bd9Sstevel@tonic-gate static List pending = { NULL, NULL }; 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate /* 6207c478bd9Sstevel@tonic-gate * If we're in the middle of an INITFIRST, this must complete before 6217c478bd9Sstevel@tonic-gate * any new init's are fired. In this case add the object list to the 6227c478bd9Sstevel@tonic-gate * pending queue and return. We'll pick up the queue after any 6237c478bd9Sstevel@tonic-gate * INITFIRST objects have their init's fired. 6247c478bd9Sstevel@tonic-gate */ 6257c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_INITFIRST) { 6267c478bd9Sstevel@tonic-gate (void) list_append(&pending, tobj); 6277c478bd9Sstevel@tonic-gate return; 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate /* 6317c478bd9Sstevel@tonic-gate * Traverse the tobj array firing each objects init. 6327c478bd9Sstevel@tonic-gate */ 6337c478bd9Sstevel@tonic-gate for (_tobj = _nobj = tobj, _nobj++; *_tobj != NULL; _tobj++, _nobj++) { 6347c478bd9Sstevel@tonic-gate Rt_map * lmp = *_tobj; 635dffec89cSrie void (* iptr)() = INIT(lmp); 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_INITCALL) 6387c478bd9Sstevel@tonic-gate continue; 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_INITCALL; 6417c478bd9Sstevel@tonic-gate 6427c478bd9Sstevel@tonic-gate /* 6437c478bd9Sstevel@tonic-gate * Establish an initfirst state if necessary - no other inits 644dffec89cSrie * will be fired (because of additional relocation bindings) 645dffec89cSrie * when in this state. 6467c478bd9Sstevel@tonic-gate */ 6477c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_INITFRST) 6487c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_INITFIRST; 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate if (INITARRAY(lmp) || iptr) { 6517c478bd9Sstevel@tonic-gate Aliste off; 6527c478bd9Sstevel@tonic-gate Bnd_desc ** bdpp; 6537c478bd9Sstevel@tonic-gate 6547c478bd9Sstevel@tonic-gate /* 6557c478bd9Sstevel@tonic-gate * Make sure that all dependencies that have been 6567c478bd9Sstevel@tonic-gate * relocated to are initialized before this objects 6577c478bd9Sstevel@tonic-gate * .init is executed. This insures that a dependency 6587c478bd9Sstevel@tonic-gate * on an external item that must first be initialized 6597c478bd9Sstevel@tonic-gate * by its associated object is satisfied. 6607c478bd9Sstevel@tonic-gate */ 6617c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(DEPENDS(lmp), off, bdpp)) { 6627c478bd9Sstevel@tonic-gate Bnd_desc * bdp = *bdpp; 6637c478bd9Sstevel@tonic-gate 6647c478bd9Sstevel@tonic-gate if ((bdp->b_flags & BND_REFER) == 0) 6657c478bd9Sstevel@tonic-gate continue; 6667c478bd9Sstevel@tonic-gate is_dep_ready(bdp->b_depend, lmp, DBG_WAIT_INIT); 6677c478bd9Sstevel@tonic-gate } 6685aefb655Srie DBG_CALL(Dbg_util_call_init(lmp, flag)); 6697c478bd9Sstevel@tonic-gate } 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate if (iptr) { 6727c478bd9Sstevel@tonic-gate leave(LIST(lmp)); 6737c478bd9Sstevel@tonic-gate (*iptr)(); 6747c478bd9Sstevel@tonic-gate (void) enter(); 6757c478bd9Sstevel@tonic-gate } 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate call_array(INITARRAY(lmp), INITARRAYSZ(lmp), lmp, 6787c478bd9Sstevel@tonic-gate SHT_INIT_ARRAY); 6797c478bd9Sstevel@tonic-gate 6807c478bd9Sstevel@tonic-gate if (INITARRAY(lmp) || iptr) 6815aefb655Srie DBG_CALL(Dbg_util_call_init(lmp, DBG_INIT_DONE)); 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate /* 6847c478bd9Sstevel@tonic-gate * Set the initdone flag regardless of whether this object 6857c478bd9Sstevel@tonic-gate * actually contains an .init section. This flag prevents us 6867c478bd9Sstevel@tonic-gate * from processing this section again for an .init and also 6877c478bd9Sstevel@tonic-gate * signifies that a .fini must be called should it exist. 6887c478bd9Sstevel@tonic-gate * Clear the sort field for use in later .fini processing. 6897c478bd9Sstevel@tonic-gate */ 6907c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_INITDONE; 691dffec89cSrie SORTVAL(lmp) = -1; 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate /* 6947c478bd9Sstevel@tonic-gate * Wake anyone up who might be waiting on this .init. 6957c478bd9Sstevel@tonic-gate */ 6967c478bd9Sstevel@tonic-gate if (FLAGS1(lmp) & FL1_RT_INITWAIT) { 6975aefb655Srie DBG_CALL(Dbg_util_broadcast(lmp)); 6987c478bd9Sstevel@tonic-gate (void) rt_cond_broadcast(CONDVAR(lmp)); 6997c478bd9Sstevel@tonic-gate FLAGS1(lmp) &= ~FL1_RT_INITWAIT; 7007c478bd9Sstevel@tonic-gate } 7017c478bd9Sstevel@tonic-gate 7027c478bd9Sstevel@tonic-gate /* 7037c478bd9Sstevel@tonic-gate * If we're firing an INITFIRST object, and other objects must 7047c478bd9Sstevel@tonic-gate * be fired which are not INITFIRST, make sure we grab any 7057c478bd9Sstevel@tonic-gate * pending objects that might have been delayed as this 7067c478bd9Sstevel@tonic-gate * INITFIRST was processed. 7077c478bd9Sstevel@tonic-gate */ 7087c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_INITFIRST) && 7097c478bd9Sstevel@tonic-gate ((*_nobj == NULL) || !(FLAGS(*_nobj) & FLG_RT_INITFRST))) { 7107c478bd9Sstevel@tonic-gate Listnode * lnp; 7117c478bd9Sstevel@tonic-gate Rt_map ** pobj; 7127c478bd9Sstevel@tonic-gate 7137c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_INITFIRST; 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate while ((lnp = pending.head) != NULL) { 7167c478bd9Sstevel@tonic-gate if ((pending.head = lnp->next) == NULL) 7177c478bd9Sstevel@tonic-gate pending.tail = NULL; 7187c478bd9Sstevel@tonic-gate pobj = lnp->data; 7197c478bd9Sstevel@tonic-gate free(lnp); 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate call_init(pobj, DBG_INIT_PEND); 7227c478bd9Sstevel@tonic-gate } 7237c478bd9Sstevel@tonic-gate } 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate free(tobj); 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate /* 7297c478bd9Sstevel@tonic-gate * Function called by atexit(3C). Calls all .fini sections related with the 7307c478bd9Sstevel@tonic-gate * mains dependent shared libraries in the order in which the shared libraries 7317c478bd9Sstevel@tonic-gate * have been loaded. Skip any .fini defined in the main executable, as this 7327c478bd9Sstevel@tonic-gate * will be called by crt0 (main was never marked as initdone). 7337c478bd9Sstevel@tonic-gate */ 7347c478bd9Sstevel@tonic-gate void 7357c478bd9Sstevel@tonic-gate call_fini(Lm_list * lml, Rt_map ** tobj) 7367c478bd9Sstevel@tonic-gate { 737dffec89cSrie Rt_map **_tobj; 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate for (_tobj = tobj; *_tobj != NULL; _tobj++) { 7407c478bd9Sstevel@tonic-gate Rt_map * clmp, * lmp = *_tobj; 7417c478bd9Sstevel@tonic-gate Aliste off; 7427c478bd9Sstevel@tonic-gate Bnd_desc ** bdpp; 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate /* 7457c478bd9Sstevel@tonic-gate * If concurrency checking isn't enabled only fire .fini if 7467c478bd9Sstevel@tonic-gate * .init has completed. We collect all .fini sections of 7477c478bd9Sstevel@tonic-gate * objects that had their .init collected, but that doesn't 7487c478bd9Sstevel@tonic-gate * mean at the time that the .init had completed. 7497c478bd9Sstevel@tonic-gate */ 7507c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_CONCUR) || 7517c478bd9Sstevel@tonic-gate (FLAGS(lmp) & FLG_RT_INITDONE)) { 752*10a4fa49Srie void (*fptr)(void) = FINI(lmp); 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate if (FINIARRAY(lmp) || fptr) { 7557c478bd9Sstevel@tonic-gate /* 7567c478bd9Sstevel@tonic-gate * If concurrency checking is enabled make sure 7577c478bd9Sstevel@tonic-gate * this object's .init is completed before 7587c478bd9Sstevel@tonic-gate * calling any .fini. 7597c478bd9Sstevel@tonic-gate */ 7607c478bd9Sstevel@tonic-gate is_dep_ready(lmp, lmp, DBG_WAIT_FINI); 7615aefb655Srie DBG_CALL(Dbg_util_call_fini(lmp)); 7627c478bd9Sstevel@tonic-gate } 7637c478bd9Sstevel@tonic-gate 7645aefb655Srie call_array(FINIARRAY(lmp), FINIARRAYSZ(lmp), lmp, 7655aefb655Srie SHT_FINI_ARRAY); 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate if (fptr) { 7687c478bd9Sstevel@tonic-gate leave(LIST(lmp)); 7697c478bd9Sstevel@tonic-gate (*fptr)(); 7707c478bd9Sstevel@tonic-gate (void) enter(); 7717c478bd9Sstevel@tonic-gate } 7727c478bd9Sstevel@tonic-gate } 7737c478bd9Sstevel@tonic-gate 774dffec89cSrie /* 775dffec89cSrie * Skip main, this is explicitly called last in atexit_fini(). 776dffec89cSrie */ 777dffec89cSrie if (FLAGS(lmp) & FLG_RT_ISMAIN) 778dffec89cSrie continue; 779dffec89cSrie 7807c478bd9Sstevel@tonic-gate /* 7817c478bd9Sstevel@tonic-gate * Audit `close' operations at this point. The library has 7827c478bd9Sstevel@tonic-gate * exercised its last instructions (regardless of whether it 7837c478bd9Sstevel@tonic-gate * will be unmapped or not). 7847c478bd9Sstevel@tonic-gate * 7857c478bd9Sstevel@tonic-gate * First call any global auditing. 7867c478bd9Sstevel@tonic-gate */ 7877c478bd9Sstevel@tonic-gate if (lml->lm_tflags & LML_TFLG_AUD_OBJCLOSE) 7887c478bd9Sstevel@tonic-gate _audit_objclose(&(auditors->ad_list), lmp); 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate /* 7917c478bd9Sstevel@tonic-gate * Finally determine whether this object has local auditing 7927c478bd9Sstevel@tonic-gate * requirements by inspecting itself and then its dependencies. 7937c478bd9Sstevel@tonic-gate */ 7947c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_LOCAUDIT) == 0) 7957c478bd9Sstevel@tonic-gate continue; 7967c478bd9Sstevel@tonic-gate 7977c478bd9Sstevel@tonic-gate if (FLAGS1(lmp) & LML_TFLG_AUD_OBJCLOSE) 7987c478bd9Sstevel@tonic-gate _audit_objclose(&(AUDITORS(lmp)->ad_list), lmp); 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(CALLERS(lmp), off, bdpp)) { 8017c478bd9Sstevel@tonic-gate Bnd_desc * bdp = *bdpp; 8027c478bd9Sstevel@tonic-gate 8037c478bd9Sstevel@tonic-gate clmp = bdp->b_caller; 8047c478bd9Sstevel@tonic-gate 8057c478bd9Sstevel@tonic-gate if (FLAGS1(clmp) & LML_TFLG_AUD_OBJCLOSE) { 8067c478bd9Sstevel@tonic-gate _audit_objclose(&(AUDITORS(clmp)->ad_list), lmp); 8077c478bd9Sstevel@tonic-gate break; 8087c478bd9Sstevel@tonic-gate } 8097c478bd9Sstevel@tonic-gate } 8107c478bd9Sstevel@tonic-gate } 8115aefb655Srie DBG_CALL(Dbg_bind_plt_summary(lml, M_MACH, pltcnt21d, pltcnt24d, 8125aefb655Srie pltcntu32, pltcntu44, pltcntfull, pltcntfar)); 8137c478bd9Sstevel@tonic-gate 8147c478bd9Sstevel@tonic-gate free(tobj); 8157c478bd9Sstevel@tonic-gate } 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate void 8187c478bd9Sstevel@tonic-gate atexit_fini() 8197c478bd9Sstevel@tonic-gate { 8207c478bd9Sstevel@tonic-gate Rt_map ** tobj, * lmp; 8217c478bd9Sstevel@tonic-gate Lm_list * lml; 8227c478bd9Sstevel@tonic-gate Listnode * lnp; 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate (void) enter(); 8257c478bd9Sstevel@tonic-gate 8267c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_ATEXIT; 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate lml = &lml_main; 829dffec89cSrie lml->lm_flags |= LML_FLG_ATEXIT; 8307c478bd9Sstevel@tonic-gate lmp = (Rt_map *)lml->lm_head; 8317c478bd9Sstevel@tonic-gate 8327c478bd9Sstevel@tonic-gate /* 8337c478bd9Sstevel@tonic-gate * Display any objects that haven't been referenced so far. 8347c478bd9Sstevel@tonic-gate */ 8357c478bd9Sstevel@tonic-gate unused(lml); 8367c478bd9Sstevel@tonic-gate 8377c478bd9Sstevel@tonic-gate /* 8387c478bd9Sstevel@tonic-gate * Reverse topologically sort the main link-map for .fini execution. 8397c478bd9Sstevel@tonic-gate */ 8407c478bd9Sstevel@tonic-gate if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != 0) && 8417c478bd9Sstevel@tonic-gate (tobj != (Rt_map **)S_ERROR)) 8427c478bd9Sstevel@tonic-gate call_fini(lml, tobj); 8437c478bd9Sstevel@tonic-gate 8447c478bd9Sstevel@tonic-gate /* 845dffec89cSrie * Add an explicit close to main and ld.so.1. Although main's .fini is 846dffec89cSrie * collected in call_fini() to provide for FINITARRAY processing, its 847dffec89cSrie * audit_objclose is explicitly skipped. This provides for it to be 848dffec89cSrie * called last, here. This is the reverse of the explicit calls to 849dffec89cSrie * audit_objopen() made in setup(). 8507c478bd9Sstevel@tonic-gate */ 8517c478bd9Sstevel@tonic-gate if ((lml->lm_tflags | FLAGS1(lmp)) & LML_TFLG_AUD_MASK) { 8527c478bd9Sstevel@tonic-gate audit_objclose(lmp, (Rt_map *)lml_rtld.lm_head); 853dffec89cSrie audit_objclose(lmp, lmp); 8547c478bd9Sstevel@tonic-gate } 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate /* 8577c478bd9Sstevel@tonic-gate * Now that all .fini code has been run, see what unreferenced objects 8587c478bd9Sstevel@tonic-gate * remain. Any difference between this and the above unused() would 8597c478bd9Sstevel@tonic-gate * indicate an object is only being used for .fini processing, which 8607c478bd9Sstevel@tonic-gate * might be fine, but might also indicate an overhead whose removal 8617c478bd9Sstevel@tonic-gate * would be worth considering. 8627c478bd9Sstevel@tonic-gate */ 8637c478bd9Sstevel@tonic-gate unused(lml); 8647c478bd9Sstevel@tonic-gate 8657c478bd9Sstevel@tonic-gate /* 8667c478bd9Sstevel@tonic-gate * Traverse any alternative link-map lists. 8677c478bd9Sstevel@tonic-gate */ 8687c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&dynlm_list, lnp, lml)) { 869*10a4fa49Srie /* 870*10a4fa49Srie * Ignore the base-link-map list, which has already been 871*10a4fa49Srie * processed, and the runtime linkers link-map list, which is 872*10a4fa49Srie * typically processed last. 873*10a4fa49Srie */ 8747c478bd9Sstevel@tonic-gate if (lml->lm_flags & (LML_FLG_BASELM | LML_FLG_RTLDLM)) 8757c478bd9Sstevel@tonic-gate continue; 8767c478bd9Sstevel@tonic-gate 8777c478bd9Sstevel@tonic-gate if ((lmp = (Rt_map *)lml->lm_head) == 0) 8787c478bd9Sstevel@tonic-gate continue; 8797c478bd9Sstevel@tonic-gate 880dffec89cSrie lml->lm_flags |= LML_FLG_ATEXIT; 881dffec89cSrie 8827c478bd9Sstevel@tonic-gate /* 8837c478bd9Sstevel@tonic-gate * Reverse topologically sort the link-map for .fini execution. 8847c478bd9Sstevel@tonic-gate */ 8857c478bd9Sstevel@tonic-gate if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != 0) && 8867c478bd9Sstevel@tonic-gate (tobj != (Rt_map **)S_ERROR)) 8877c478bd9Sstevel@tonic-gate call_fini(lml, tobj); 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate unused(lml); 8907c478bd9Sstevel@tonic-gate } 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate /* 8937c478bd9Sstevel@tonic-gate * Finally reverse topologically sort the runtime linkers link-map for 8947c478bd9Sstevel@tonic-gate * .fini execution. 8957c478bd9Sstevel@tonic-gate */ 8967c478bd9Sstevel@tonic-gate lml = &lml_rtld; 897dffec89cSrie lml->lm_flags |= LML_FLG_ATEXIT; 8987c478bd9Sstevel@tonic-gate lmp = (Rt_map *)lml->lm_head; 8997c478bd9Sstevel@tonic-gate 9007c478bd9Sstevel@tonic-gate if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != 0) && 9017c478bd9Sstevel@tonic-gate (tobj != (Rt_map **)S_ERROR)) 9027c478bd9Sstevel@tonic-gate call_fini(lml, tobj); 9037c478bd9Sstevel@tonic-gate 9047c478bd9Sstevel@tonic-gate leave(&lml_main); 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate 9087c478bd9Sstevel@tonic-gate /* 9097c478bd9Sstevel@tonic-gate * This routine is called to complete any runtime linker activity which may have 9107c478bd9Sstevel@tonic-gate * resulted in objects being loaded. This is called from all user entry points 9117c478bd9Sstevel@tonic-gate * and from any internal dl*() requests. 9127c478bd9Sstevel@tonic-gate */ 9137c478bd9Sstevel@tonic-gate void 914*10a4fa49Srie load_completion(Rt_map *nlmp, Rt_map *clmp) 9157c478bd9Sstevel@tonic-gate { 9167c478bd9Sstevel@tonic-gate Rt_map **tobj = 0; 917*10a4fa49Srie Lm_list *nlml, *clml; 9187c478bd9Sstevel@tonic-gate 9197c478bd9Sstevel@tonic-gate /* 9207c478bd9Sstevel@tonic-gate * Establish any .init processing. Note, in a world of lazy loading, 9217c478bd9Sstevel@tonic-gate * objects may have been loaded regardless of whether the users request 9227c478bd9Sstevel@tonic-gate * was fulfilled (i.e., a dlsym() request may have failed to find a 9237c478bd9Sstevel@tonic-gate * symbol but objects might have been loaded during its search). Thus, 9247c478bd9Sstevel@tonic-gate * any tsorting starts from the nlmp (new link-maps) pointer and not 9257c478bd9Sstevel@tonic-gate * necessarily from the link-map that may have satisfied the request. 9267c478bd9Sstevel@tonic-gate * 927*10a4fa49Srie * Note, the primary link-map has an initialization phase where dynamic 928*10a4fa49Srie * .init firing is suppressed. This provides for a simple and clean 929*10a4fa49Srie * handshake with the primary link-maps libc, which is important for 930*10a4fa49Srie * establishing uberdata. In addition, auditors often obtain handles 931*10a4fa49Srie * to primary link-map objects as the objects are loaded, so as to 932*10a4fa49Srie * inspect the link-map for symbols. This inspection is allowed without 933*10a4fa49Srie * running any code on the primary link-map, as running this code may 934*10a4fa49Srie * reenter the auditor, who may not yet have finished its own 9357c478bd9Sstevel@tonic-gate * initialization. 9367c478bd9Sstevel@tonic-gate */ 937*10a4fa49Srie if (nlmp) 938*10a4fa49Srie nlml = LIST(nlmp); 939*10a4fa49Srie if (clmp) 940*10a4fa49Srie clml = LIST(clmp); 941*10a4fa49Srie 942*10a4fa49Srie if (nlmp && nlml->lm_init && 943*10a4fa49Srie ((nlml != &lml_main) || (rtld_flags2 & RT_FL2_PLMSETUP))) { 944dffec89cSrie if ((tobj = tsort(nlmp, LIST(nlmp)->lm_init, 945dffec89cSrie RT_SORT_REV)) == (Rt_map **)S_ERROR) 9467c478bd9Sstevel@tonic-gate tobj = 0; 9477c478bd9Sstevel@tonic-gate } 9487c478bd9Sstevel@tonic-gate 949*10a4fa49Srie /* 950*10a4fa49Srie * Make sure any alternative link-map retrieves any external interfaces 951*10a4fa49Srie * and initializes threads. 952*10a4fa49Srie */ 953*10a4fa49Srie if (nlmp && (nlml != &lml_main)) { 954*10a4fa49Srie (void) rt_get_extern(nlml, nlmp); 955*10a4fa49Srie rt_thr_init(nlml); 956*10a4fa49Srie } 957*10a4fa49Srie 958*10a4fa49Srie /* 959*10a4fa49Srie * Traverse the list of new link-maps and register any dynamic TLS. 960*10a4fa49Srie * This storage is established for any objects not on the primary 961*10a4fa49Srie * link-map, and for any objects added to the primary link-map after 962*10a4fa49Srie * static TLS has been registered. 963*10a4fa49Srie */ 964*10a4fa49Srie if (nlmp && nlml->lm_tls && 965*10a4fa49Srie ((nlml != &lml_main) || (rtld_flags2 & RT_FL2_PLMSETUP))) { 966*10a4fa49Srie Rt_map *lmp; 967*10a4fa49Srie 968*10a4fa49Srie for (lmp = nlmp; lmp; lmp = (Rt_map *)NEXT(lmp)) { 969*10a4fa49Srie if (PTTLS(lmp) && PTTLS(lmp)->p_memsz) 970*10a4fa49Srie tls_modaddrem(lmp, TM_FLG_MODADD); 971*10a4fa49Srie } 972*10a4fa49Srie nlml->lm_tls = 0; 973*10a4fa49Srie } 974*10a4fa49Srie 9757c478bd9Sstevel@tonic-gate /* 9767c478bd9Sstevel@tonic-gate * Indicate the link-map list is consistent. 9777c478bd9Sstevel@tonic-gate */ 978*10a4fa49Srie if (clmp && ((clml->lm_tflags | FLAGS1(clmp)) & LML_TFLG_AUD_ACTIVITY)) 9797c478bd9Sstevel@tonic-gate audit_activity(clmp, LA_ACT_CONSISTENT); 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate /* 9827c478bd9Sstevel@tonic-gate * Fire any .init's. 9837c478bd9Sstevel@tonic-gate */ 9847c478bd9Sstevel@tonic-gate if (tobj) 9857c478bd9Sstevel@tonic-gate call_init(tobj, DBG_INIT_SORT); 9867c478bd9Sstevel@tonic-gate } 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate /* 9897c478bd9Sstevel@tonic-gate * Append an item to the specified list, and return a pointer to the list 9907c478bd9Sstevel@tonic-gate * node created. 9917c478bd9Sstevel@tonic-gate */ 9927c478bd9Sstevel@tonic-gate Listnode * 9937c478bd9Sstevel@tonic-gate list_append(List *lst, const void *item) 9947c478bd9Sstevel@tonic-gate { 9957c478bd9Sstevel@tonic-gate Listnode * _lnp; 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate if ((_lnp = malloc(sizeof (Listnode))) == 0) 9987c478bd9Sstevel@tonic-gate return (0); 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate _lnp->data = (void *)item; 10017c478bd9Sstevel@tonic-gate _lnp->next = NULL; 10027c478bd9Sstevel@tonic-gate 10037c478bd9Sstevel@tonic-gate if (lst->head == NULL) 10047c478bd9Sstevel@tonic-gate lst->tail = lst->head = _lnp; 10057c478bd9Sstevel@tonic-gate else { 10067c478bd9Sstevel@tonic-gate lst->tail->next = _lnp; 10077c478bd9Sstevel@tonic-gate lst->tail = lst->tail->next; 10087c478bd9Sstevel@tonic-gate } 10097c478bd9Sstevel@tonic-gate return (_lnp); 10107c478bd9Sstevel@tonic-gate } 10117c478bd9Sstevel@tonic-gate 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate /* 10147c478bd9Sstevel@tonic-gate * Add an item after specified listnode, and return a pointer to the list 10157c478bd9Sstevel@tonic-gate * node created. 10167c478bd9Sstevel@tonic-gate */ 10177c478bd9Sstevel@tonic-gate Listnode * 10187c478bd9Sstevel@tonic-gate list_insert(List *lst, const void *item, Listnode *lnp) 10197c478bd9Sstevel@tonic-gate { 10207c478bd9Sstevel@tonic-gate Listnode * _lnp; 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate if ((_lnp = malloc(sizeof (Listnode))) == (Listnode *)0) 10237c478bd9Sstevel@tonic-gate return (0); 10247c478bd9Sstevel@tonic-gate 10257c478bd9Sstevel@tonic-gate _lnp->data = (void *)item; 10267c478bd9Sstevel@tonic-gate _lnp->next = lnp->next; 10277c478bd9Sstevel@tonic-gate if (_lnp->next == NULL) 10287c478bd9Sstevel@tonic-gate lst->tail = _lnp; 10297c478bd9Sstevel@tonic-gate lnp->next = _lnp; 10307c478bd9Sstevel@tonic-gate return (_lnp); 10317c478bd9Sstevel@tonic-gate } 10327c478bd9Sstevel@tonic-gate 10337c478bd9Sstevel@tonic-gate /* 10347c478bd9Sstevel@tonic-gate * Prepend an item to the specified list, and return a pointer to the 10357c478bd9Sstevel@tonic-gate * list node created. 10367c478bd9Sstevel@tonic-gate */ 10377c478bd9Sstevel@tonic-gate Listnode * 10387c478bd9Sstevel@tonic-gate list_prepend(List * lst, const void * item) 10397c478bd9Sstevel@tonic-gate { 10407c478bd9Sstevel@tonic-gate Listnode * _lnp; 10417c478bd9Sstevel@tonic-gate 10427c478bd9Sstevel@tonic-gate if ((_lnp = malloc(sizeof (Listnode))) == (Listnode *)0) 10437c478bd9Sstevel@tonic-gate return (0); 10447c478bd9Sstevel@tonic-gate 10457c478bd9Sstevel@tonic-gate _lnp->data = (void *)item; 10467c478bd9Sstevel@tonic-gate 10477c478bd9Sstevel@tonic-gate if (lst->head == NULL) { 10487c478bd9Sstevel@tonic-gate _lnp->next = NULL; 10497c478bd9Sstevel@tonic-gate lst->tail = lst->head = _lnp; 10507c478bd9Sstevel@tonic-gate } else { 10517c478bd9Sstevel@tonic-gate _lnp->next = lst->head; 10527c478bd9Sstevel@tonic-gate lst->head = _lnp; 10537c478bd9Sstevel@tonic-gate } 10547c478bd9Sstevel@tonic-gate return (_lnp); 10557c478bd9Sstevel@tonic-gate } 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate /* 10597c478bd9Sstevel@tonic-gate * Delete a 'listnode' from a list. 10607c478bd9Sstevel@tonic-gate */ 10617c478bd9Sstevel@tonic-gate void 10627c478bd9Sstevel@tonic-gate list_delete(List * lst, void * item) 10637c478bd9Sstevel@tonic-gate { 10647c478bd9Sstevel@tonic-gate Listnode * clnp, * plnp; 10657c478bd9Sstevel@tonic-gate 10667c478bd9Sstevel@tonic-gate for (plnp = NULL, clnp = lst->head; clnp; clnp = clnp->next) { 10677c478bd9Sstevel@tonic-gate if (item == clnp->data) 10687c478bd9Sstevel@tonic-gate break; 10697c478bd9Sstevel@tonic-gate plnp = clnp; 10707c478bd9Sstevel@tonic-gate } 10717c478bd9Sstevel@tonic-gate 10727c478bd9Sstevel@tonic-gate if (clnp == 0) 10737c478bd9Sstevel@tonic-gate return; 10747c478bd9Sstevel@tonic-gate 10757c478bd9Sstevel@tonic-gate if (lst->head == clnp) 10767c478bd9Sstevel@tonic-gate lst->head = clnp->next; 10777c478bd9Sstevel@tonic-gate if (lst->tail == clnp) 10787c478bd9Sstevel@tonic-gate lst->tail = plnp; 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate if (plnp) 10817c478bd9Sstevel@tonic-gate plnp->next = clnp->next; 10827c478bd9Sstevel@tonic-gate 10837c478bd9Sstevel@tonic-gate free(clnp); 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate /* 10877c478bd9Sstevel@tonic-gate * Append an item to the specified link map control list. 10887c478bd9Sstevel@tonic-gate */ 10897c478bd9Sstevel@tonic-gate void 10907c478bd9Sstevel@tonic-gate lm_append(Lm_list *lml, Aliste lmco, Rt_map *lmp) 10917c478bd9Sstevel@tonic-gate { 10927c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 10937c478bd9Sstevel@tonic-gate int add = 1; 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate /* 10967c478bd9Sstevel@tonic-gate * Indicate that this link-map list has a new object. 10977c478bd9Sstevel@tonic-gate */ 10987c478bd9Sstevel@tonic-gate (lml->lm_obj)++; 10997c478bd9Sstevel@tonic-gate 11007c478bd9Sstevel@tonic-gate /* 11017c478bd9Sstevel@tonic-gate * Alert the debuggers that we are about to mess with the main link-map 11027c478bd9Sstevel@tonic-gate * control list. 11037c478bd9Sstevel@tonic-gate */ 11047c478bd9Sstevel@tonic-gate if ((lmco == ALO_DATA) && ((lml->lm_flags & LML_FLG_DBNOTIF) == 0)) 11057c478bd9Sstevel@tonic-gate rd_event(lml, RD_DLACTIVITY, RT_DELETE); 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate /* LINTED */ 11087c478bd9Sstevel@tonic-gate lmc = (Lm_cntl *)((char *)lml->lm_lists + lmco); 11097c478bd9Sstevel@tonic-gate 11107c478bd9Sstevel@tonic-gate /* 11117c478bd9Sstevel@tonic-gate * A link-map list header points to one of more link-map control lists 11127c478bd9Sstevel@tonic-gate * (see include/rtld.h). The initial list, pointed to by lm_cntl, is 11137c478bd9Sstevel@tonic-gate * the list of relocated objects. Other lists maintain objects that 11147c478bd9Sstevel@tonic-gate * are still being analyzed or relocated. This list provides the core 11157c478bd9Sstevel@tonic-gate * link-map list information used by all ld.so.1 routines. 11167c478bd9Sstevel@tonic-gate */ 11177c478bd9Sstevel@tonic-gate if (lmc->lc_head == NULL) { 11187c478bd9Sstevel@tonic-gate /* 11197c478bd9Sstevel@tonic-gate * If this is the first link-map for the given control list, 11207c478bd9Sstevel@tonic-gate * initialize the list. 11217c478bd9Sstevel@tonic-gate */ 11227c478bd9Sstevel@tonic-gate lmc->lc_head = lmc->lc_tail = lmp; 11237c478bd9Sstevel@tonic-gate add = 0; 11247c478bd9Sstevel@tonic-gate 11257c478bd9Sstevel@tonic-gate } else if (FLAGS(lmp) & FLG_RT_INTRPOSE) { 11267c478bd9Sstevel@tonic-gate Rt_map *tlmp; 11277c478bd9Sstevel@tonic-gate 11287c478bd9Sstevel@tonic-gate /* 11297c478bd9Sstevel@tonic-gate * If this is an interposer then append the link-map following 11307c478bd9Sstevel@tonic-gate * any other interposers (these are objects that have been 11317c478bd9Sstevel@tonic-gate * previously preloaded, or were identified with -z interpose). 11327c478bd9Sstevel@tonic-gate * Interposers can only be inserted on the first link-map 11337c478bd9Sstevel@tonic-gate * control list, as once relocation has started, interposition 11347c478bd9Sstevel@tonic-gate * from new interposers can't be guaranteed. 11357c478bd9Sstevel@tonic-gate * 11367c478bd9Sstevel@tonic-gate * NOTE: We do not interpose on the head of a list. This model 11377c478bd9Sstevel@tonic-gate * evolved because dynamic executables have already been fully 11387c478bd9Sstevel@tonic-gate * relocated within themselves and thus can't be interposed on. 11397c478bd9Sstevel@tonic-gate * Nowadays it's possible to have shared objects at the head of 11407c478bd9Sstevel@tonic-gate * a list, which conceptually means they could be interposed on. 11417c478bd9Sstevel@tonic-gate * But, shared objects can be created via dldump() and may only 11427c478bd9Sstevel@tonic-gate * be partially relocated (just relatives), in which case they 11437c478bd9Sstevel@tonic-gate * are interposable, but are marked as fixed (ET_EXEC). 11447c478bd9Sstevel@tonic-gate * 11457c478bd9Sstevel@tonic-gate * Thus we really don't have a clear method of deciding when the 11467c478bd9Sstevel@tonic-gate * head of a link-map is interposable. So, to be consistent, 11477c478bd9Sstevel@tonic-gate * for now only add interposers after the link-map lists head 11487c478bd9Sstevel@tonic-gate * object. 11497c478bd9Sstevel@tonic-gate */ 11507c478bd9Sstevel@tonic-gate for (tlmp = (Rt_map *)NEXT(lmc->lc_head); tlmp; 11517c478bd9Sstevel@tonic-gate tlmp = (Rt_map *)NEXT(tlmp)) { 11527c478bd9Sstevel@tonic-gate 11537c478bd9Sstevel@tonic-gate if (FLAGS(tlmp) & FLG_RT_INTRPOSE) 11547c478bd9Sstevel@tonic-gate continue; 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate /* 11577c478bd9Sstevel@tonic-gate * Insert the new link-map before this non-interposer, 11587c478bd9Sstevel@tonic-gate * and indicate an interposer is found. 11597c478bd9Sstevel@tonic-gate */ 11607c478bd9Sstevel@tonic-gate NEXT((Rt_map *)PREV(tlmp)) = (Link_map *)lmp; 11617c478bd9Sstevel@tonic-gate PREV(lmp) = PREV(tlmp); 11627c478bd9Sstevel@tonic-gate 11637c478bd9Sstevel@tonic-gate NEXT(lmp) = (Link_map *)tlmp; 11647c478bd9Sstevel@tonic-gate PREV(tlmp) = (Link_map *)lmp; 11657c478bd9Sstevel@tonic-gate 11667c478bd9Sstevel@tonic-gate lmc->lc_flags |= LMC_FLG_REANALYZE; 11677c478bd9Sstevel@tonic-gate add = 0; 11687c478bd9Sstevel@tonic-gate break; 11697c478bd9Sstevel@tonic-gate } 11707c478bd9Sstevel@tonic-gate } 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate /* 11737c478bd9Sstevel@tonic-gate * Fall through to appending the new link map to the tail of the list. 11747c478bd9Sstevel@tonic-gate * If we're processing the initial objects of this link-map list, add 11757c478bd9Sstevel@tonic-gate * them to the backward compatibility list. 11767c478bd9Sstevel@tonic-gate */ 11777c478bd9Sstevel@tonic-gate if (add) { 11787c478bd9Sstevel@tonic-gate NEXT(lmc->lc_tail) = (Link_map *)lmp; 11797c478bd9Sstevel@tonic-gate PREV(lmp) = (Link_map *)lmc->lc_tail; 11807c478bd9Sstevel@tonic-gate lmc->lc_tail = lmp; 11817c478bd9Sstevel@tonic-gate } 11827c478bd9Sstevel@tonic-gate 11837c478bd9Sstevel@tonic-gate /* 11847c478bd9Sstevel@tonic-gate * Having added this link-map to a control list, indicate which control 11857c478bd9Sstevel@tonic-gate * list the link-map belongs to. Note, control list information is 11867c478bd9Sstevel@tonic-gate * always maintained as an offset, as the Alist can be reallocated. 11877c478bd9Sstevel@tonic-gate */ 11887c478bd9Sstevel@tonic-gate CNTL(lmp) = lmco; 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate /* 11917c478bd9Sstevel@tonic-gate * Indicate if an interposer is found. Note that the first object on a 11927c478bd9Sstevel@tonic-gate * link-map can be explicitly defined as an interposer so that it can 11937c478bd9Sstevel@tonic-gate * provide interposition over direct binding requests. 11947c478bd9Sstevel@tonic-gate */ 11957c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_INTRPOSE) 11967c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_INTRPOSE; 11977c478bd9Sstevel@tonic-gate 11987c478bd9Sstevel@tonic-gate /* 11997c478bd9Sstevel@tonic-gate * For backward compatibility with debuggers, the link-map list contains 12007c478bd9Sstevel@tonic-gate * pointers to the main control list. 12017c478bd9Sstevel@tonic-gate */ 12027c478bd9Sstevel@tonic-gate if (lmco == ALO_DATA) { 12037c478bd9Sstevel@tonic-gate lml->lm_head = lmc->lc_head; 12047c478bd9Sstevel@tonic-gate lml->lm_tail = lmc->lc_tail; 12057c478bd9Sstevel@tonic-gate } 12067c478bd9Sstevel@tonic-gate } 12077c478bd9Sstevel@tonic-gate 12087c478bd9Sstevel@tonic-gate /* 12097c478bd9Sstevel@tonic-gate * Delete an item from the specified link map control list. 12107c478bd9Sstevel@tonic-gate */ 12117c478bd9Sstevel@tonic-gate void 12127c478bd9Sstevel@tonic-gate lm_delete(Lm_list *lml, Rt_map *lmp) 12137c478bd9Sstevel@tonic-gate { 12147c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 12157c478bd9Sstevel@tonic-gate 12167c478bd9Sstevel@tonic-gate /* 12177c478bd9Sstevel@tonic-gate * If the control list pointer hasn't been initialized, this object 12187c478bd9Sstevel@tonic-gate * never got added to a link-map list. 12197c478bd9Sstevel@tonic-gate */ 12207c478bd9Sstevel@tonic-gate if (CNTL(lmp) == 0) 12217c478bd9Sstevel@tonic-gate return; 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate /* 12247c478bd9Sstevel@tonic-gate * Alert the debuggers that we are about to mess with the main link-map 12257c478bd9Sstevel@tonic-gate * control list. 12267c478bd9Sstevel@tonic-gate */ 12277c478bd9Sstevel@tonic-gate if ((CNTL(lmp) == ALO_DATA) && ((lml->lm_flags & LML_FLG_DBNOTIF) == 0)) 12287c478bd9Sstevel@tonic-gate rd_event(lml, RD_DLACTIVITY, RT_DELETE); 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate /* LINTED */ 12317c478bd9Sstevel@tonic-gate lmc = (Lm_cntl *)((char *)lml->lm_lists + CNTL(lmp)); 12327c478bd9Sstevel@tonic-gate 12337c478bd9Sstevel@tonic-gate if (lmc->lc_head == lmp) 12347c478bd9Sstevel@tonic-gate lmc->lc_head = (Rt_map *)NEXT(lmp); 12357c478bd9Sstevel@tonic-gate else 12367c478bd9Sstevel@tonic-gate NEXT((Rt_map *)PREV(lmp)) = (void *)NEXT(lmp); 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate if (lmc->lc_tail == lmp) 12397c478bd9Sstevel@tonic-gate lmc->lc_tail = (Rt_map *)PREV(lmp); 12407c478bd9Sstevel@tonic-gate else 12417c478bd9Sstevel@tonic-gate PREV((Rt_map *)NEXT(lmp)) = PREV(lmp); 12427c478bd9Sstevel@tonic-gate 12437c478bd9Sstevel@tonic-gate /* 12447c478bd9Sstevel@tonic-gate * For backward compatibility with debuggers, the link-map list contains 12457c478bd9Sstevel@tonic-gate * pointers to the main control list. 12467c478bd9Sstevel@tonic-gate */ 12477c478bd9Sstevel@tonic-gate if (lmc == (Lm_cntl *)&(lml->lm_lists->al_data)) { 12487c478bd9Sstevel@tonic-gate lml->lm_head = lmc->lc_head; 12497c478bd9Sstevel@tonic-gate lml->lm_tail = lmc->lc_tail; 12507c478bd9Sstevel@tonic-gate } 12517c478bd9Sstevel@tonic-gate 12527c478bd9Sstevel@tonic-gate /* 12537c478bd9Sstevel@tonic-gate * Indicate we have one less object on this control list. 12547c478bd9Sstevel@tonic-gate */ 12557c478bd9Sstevel@tonic-gate (lml->lm_obj)--; 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate 12587c478bd9Sstevel@tonic-gate /* 12597c478bd9Sstevel@tonic-gate * Move a link-map control list to another. Objects that are being relocated 12607c478bd9Sstevel@tonic-gate * are maintained on secondary control lists. Once their relocation is 12617c478bd9Sstevel@tonic-gate * complete, the entire list is appended to the previous control list, as this 12627c478bd9Sstevel@tonic-gate * list must have been the trigger for generating the new control list. 12637c478bd9Sstevel@tonic-gate */ 12647c478bd9Sstevel@tonic-gate void 12657c478bd9Sstevel@tonic-gate lm_move(Lm_list *lml, Aliste nlmco, Aliste plmco, Lm_cntl *nlmc, Lm_cntl *plmc) 12667c478bd9Sstevel@tonic-gate { 12677c478bd9Sstevel@tonic-gate Rt_map *lmp; 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate DBG_CALL(Dbg_file_cntl(lml, nlmco, plmco)); 12707c478bd9Sstevel@tonic-gate 12717c478bd9Sstevel@tonic-gate /* 12727c478bd9Sstevel@tonic-gate * Alert the debuggers that we are about to mess with the main link-map 12737c478bd9Sstevel@tonic-gate * control list. 12747c478bd9Sstevel@tonic-gate */ 12757c478bd9Sstevel@tonic-gate if ((plmco == ALO_DATA) && ((lml->lm_flags & LML_FLG_DBNOTIF) == 0)) 12767c478bd9Sstevel@tonic-gate rd_event(lml, RD_DLACTIVITY, RT_ADD); 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate /* 12797c478bd9Sstevel@tonic-gate * Indicate each new link-map has been moved to the previous link-map 12807c478bd9Sstevel@tonic-gate * control list. 12817c478bd9Sstevel@tonic-gate */ 12827c478bd9Sstevel@tonic-gate for (lmp = nlmc->lc_head; lmp; lmp = (Rt_map *)NEXT(lmp)) 12837c478bd9Sstevel@tonic-gate CNTL(lmp) = plmco; 12847c478bd9Sstevel@tonic-gate 12857c478bd9Sstevel@tonic-gate /* 12867c478bd9Sstevel@tonic-gate * Move the new link-map control list, to the callers link-map control 12877c478bd9Sstevel@tonic-gate * list. 12887c478bd9Sstevel@tonic-gate */ 12897c478bd9Sstevel@tonic-gate if (plmc->lc_head == 0) { 12907c478bd9Sstevel@tonic-gate plmc->lc_head = nlmc->lc_head; 12917c478bd9Sstevel@tonic-gate PREV(nlmc->lc_head) = 0; 12927c478bd9Sstevel@tonic-gate } else { 12937c478bd9Sstevel@tonic-gate NEXT(plmc->lc_tail) = (Link_map *)nlmc->lc_head; 12947c478bd9Sstevel@tonic-gate PREV(nlmc->lc_head) = (Link_map *)plmc->lc_tail; 12957c478bd9Sstevel@tonic-gate } 12967c478bd9Sstevel@tonic-gate 12977c478bd9Sstevel@tonic-gate plmc->lc_tail = nlmc->lc_tail; 12987c478bd9Sstevel@tonic-gate nlmc->lc_head = nlmc->lc_tail = 0; 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate /* 13017c478bd9Sstevel@tonic-gate * For backward compatibility with debuggers, the link-map list contains 13027c478bd9Sstevel@tonic-gate * pointers to the main control list. 13037c478bd9Sstevel@tonic-gate */ 13047c478bd9Sstevel@tonic-gate if (plmco == ALO_DATA) { 13057c478bd9Sstevel@tonic-gate lml->lm_head = plmc->lc_head; 13067c478bd9Sstevel@tonic-gate lml->lm_tail = plmc->lc_tail; 13077c478bd9Sstevel@tonic-gate } 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate /* 13117c478bd9Sstevel@tonic-gate * Dlopening a family of objects occurs on a new link-map control list. If the 13127c478bd9Sstevel@tonic-gate * dlopen fails, then its handle is used to tear down the family (dlclose). 13137c478bd9Sstevel@tonic-gate * However, the relocation of this family may have triggered other objects to 13147c478bd9Sstevel@tonic-gate * be loaded, and after their relocation they will have been moved to the 13157c478bd9Sstevel@tonic-gate * dlopen families control list. After a dlopen() failure, see if there are 13167c478bd9Sstevel@tonic-gate * any objects that can be savaged before tearing down this control list. 13177c478bd9Sstevel@tonic-gate */ 13187c478bd9Sstevel@tonic-gate int 13197c478bd9Sstevel@tonic-gate lm_salvage(Lm_list *lml, int test, Aliste nlmco) 13207c478bd9Sstevel@tonic-gate { 13217c478bd9Sstevel@tonic-gate Lm_cntl *nlmc; 13227c478bd9Sstevel@tonic-gate 13237c478bd9Sstevel@tonic-gate /* 13247c478bd9Sstevel@tonic-gate * If a dlopen occurred on a new link-map list, then its dlclose may 13257c478bd9Sstevel@tonic-gate * have completely torn down the link-map list. Check that the link-map 13267c478bd9Sstevel@tonic-gate * list still exists before proceeding. 13277c478bd9Sstevel@tonic-gate */ 13287c478bd9Sstevel@tonic-gate if (test) { 13297c478bd9Sstevel@tonic-gate Listnode *lnp; 13307c478bd9Sstevel@tonic-gate Lm_list *tlml; 13317c478bd9Sstevel@tonic-gate int found = 0; 13327c478bd9Sstevel@tonic-gate 13337c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&dynlm_list, lnp, tlml)) { 13347c478bd9Sstevel@tonic-gate if (tlml == lml) { 13357c478bd9Sstevel@tonic-gate found++; 13367c478bd9Sstevel@tonic-gate break; 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate } 13397c478bd9Sstevel@tonic-gate if (found == 0) 13407c478bd9Sstevel@tonic-gate return (0); 13417c478bd9Sstevel@tonic-gate } 13427c478bd9Sstevel@tonic-gate 13437c478bd9Sstevel@tonic-gate /* LINTED */ 13447c478bd9Sstevel@tonic-gate nlmc = (Lm_cntl *)((char *)lml->lm_lists + nlmco); 13457c478bd9Sstevel@tonic-gate 13467c478bd9Sstevel@tonic-gate /* 13477c478bd9Sstevel@tonic-gate * If this link-map control list still contains objects, determine the 13487c478bd9Sstevel@tonic-gate * previous control list and move the objects. 13497c478bd9Sstevel@tonic-gate */ 13507c478bd9Sstevel@tonic-gate if (nlmc->lc_head) { 13517c478bd9Sstevel@tonic-gate Lm_cntl *plmc; 13527c478bd9Sstevel@tonic-gate Aliste plmco; 13537c478bd9Sstevel@tonic-gate 13547c478bd9Sstevel@tonic-gate plmco = nlmco - lml->lm_lists->al_size; 13557c478bd9Sstevel@tonic-gate /* LINTED */ 13567c478bd9Sstevel@tonic-gate plmc = (Lm_cntl *)((char *)lml->lm_lists + plmco); 13577c478bd9Sstevel@tonic-gate 13587c478bd9Sstevel@tonic-gate lm_move(lml, nlmco, plmco, nlmc, plmc); 13597c478bd9Sstevel@tonic-gate } 13607c478bd9Sstevel@tonic-gate return (1); 13617c478bd9Sstevel@tonic-gate } 13627c478bd9Sstevel@tonic-gate 13637c478bd9Sstevel@tonic-gate /* 13647c478bd9Sstevel@tonic-gate * Environment variables can have a variety of defined permutations, and thus 13657c478bd9Sstevel@tonic-gate * the following infrastructure exists to allow this variety and to select the 13667c478bd9Sstevel@tonic-gate * required definition. 13677c478bd9Sstevel@tonic-gate * 13687c478bd9Sstevel@tonic-gate * Environment variables can be defined as 32- or 64-bit specific, and if so 13697c478bd9Sstevel@tonic-gate * they will take precedence over any instruction set neutral form. Typically 13707c478bd9Sstevel@tonic-gate * this is only useful when the environment value is an informational string. 13717c478bd9Sstevel@tonic-gate * 13727c478bd9Sstevel@tonic-gate * Environment variables may be obtained from the standard user environment or 13737c478bd9Sstevel@tonic-gate * from a configuration file. The latter provides a fallback if no user 13747c478bd9Sstevel@tonic-gate * environment setting is found, and can take two forms: 13757c478bd9Sstevel@tonic-gate * 13767c478bd9Sstevel@tonic-gate * . a replaceable definition - this will be used if no user environment 13777c478bd9Sstevel@tonic-gate * setting has been seen, or 13787c478bd9Sstevel@tonic-gate * 13797c478bd9Sstevel@tonic-gate * . an permanent definition - this will be used no matter what user 13807c478bd9Sstevel@tonic-gate * environment setting is seen. In the case of list variables it will be 13817c478bd9Sstevel@tonic-gate * appended to any process environment setting seen. 13827c478bd9Sstevel@tonic-gate * 13837c478bd9Sstevel@tonic-gate * Environment variables can be defined without a value (ie. LD_XXXX=) so as to 13847c478bd9Sstevel@tonic-gate * override any replaceable environment variables from a configuration file. 13857c478bd9Sstevel@tonic-gate */ 13867c478bd9Sstevel@tonic-gate static u_longlong_t rplgen; /* replaceable generic */ 13877c478bd9Sstevel@tonic-gate /* variables */ 13887c478bd9Sstevel@tonic-gate static u_longlong_t rplisa; /* replaceable ISA specific */ 13897c478bd9Sstevel@tonic-gate /* variables */ 13907c478bd9Sstevel@tonic-gate static u_longlong_t prmgen; /* permanent generic */ 13917c478bd9Sstevel@tonic-gate /* variables */ 13927c478bd9Sstevel@tonic-gate static u_longlong_t prmisa; /* permanent ISA specific */ 13937c478bd9Sstevel@tonic-gate /* variables */ 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate /* 13967c478bd9Sstevel@tonic-gate * Classify an environment variables type. 13977c478bd9Sstevel@tonic-gate */ 13987c478bd9Sstevel@tonic-gate #define ENV_TYP_IGNORE 0x1 /* ignore - variable is for */ 13997c478bd9Sstevel@tonic-gate /* the wrong ISA */ 14007c478bd9Sstevel@tonic-gate #define ENV_TYP_ISA 0x2 /* variable is ISA specific */ 14017c478bd9Sstevel@tonic-gate #define ENV_TYP_CONFIG 0x4 /* variable obtained from a */ 14027c478bd9Sstevel@tonic-gate /* config file */ 14037c478bd9Sstevel@tonic-gate #define ENV_TYP_PERMANT 0x8 /* variable is permanent */ 14047c478bd9Sstevel@tonic-gate 14057c478bd9Sstevel@tonic-gate /* 14067c478bd9Sstevel@tonic-gate * Identify all environment variables. 14077c478bd9Sstevel@tonic-gate */ 14087c478bd9Sstevel@tonic-gate #define ENV_FLG_AUDIT 0x0000000001ULL 14097c478bd9Sstevel@tonic-gate #define ENV_FLG_AUDIT_ARGS 0x0000000002ULL 14107c478bd9Sstevel@tonic-gate #define ENV_FLG_BIND_NOW 0x0000000004ULL 14117c478bd9Sstevel@tonic-gate #define ENV_FLG_BIND_NOT 0x0000000008ULL 14127c478bd9Sstevel@tonic-gate #define ENV_FLG_BINDINGS 0x0000000010ULL 14137c478bd9Sstevel@tonic-gate #define ENV_FLG_CONCURRENCY 0x0000000020ULL 14147c478bd9Sstevel@tonic-gate #define ENV_FLG_CONFGEN 0x0000000040ULL 14157c478bd9Sstevel@tonic-gate #define ENV_FLG_CONFIG 0x0000000080ULL 14167c478bd9Sstevel@tonic-gate #define ENV_FLG_DEBUG 0x0000000100ULL 14177c478bd9Sstevel@tonic-gate #define ENV_FLG_DEBUG_OUTPUT 0x0000000200ULL 14187c478bd9Sstevel@tonic-gate #define ENV_FLG_DEMANGLE 0x0000000400ULL 14197c478bd9Sstevel@tonic-gate #define ENV_FLG_FLAGS 0x0000000800ULL 14207c478bd9Sstevel@tonic-gate #define ENV_FLG_INIT 0x0000001000ULL 14217c478bd9Sstevel@tonic-gate #define ENV_FLG_LIBPATH 0x0000002000ULL 14227c478bd9Sstevel@tonic-gate #define ENV_FLG_LOADAVAIL 0x0000004000ULL 14237c478bd9Sstevel@tonic-gate #define ENV_FLG_LOADFLTR 0x0000008000ULL 14247c478bd9Sstevel@tonic-gate #define ENV_FLG_NOAUDIT 0x0000010000ULL 14257c478bd9Sstevel@tonic-gate #define ENV_FLG_NOAUXFLTR 0x0000020000ULL 14267c478bd9Sstevel@tonic-gate #define ENV_FLG_NOBAPLT 0x0000040000ULL 14277c478bd9Sstevel@tonic-gate #define ENV_FLG_NOCONFIG 0x0000080000ULL 14287c478bd9Sstevel@tonic-gate #define ENV_FLG_NODIRCONFIG 0x0000100000ULL 14297c478bd9Sstevel@tonic-gate #define ENV_FLG_NODIRECT 0x0000200000ULL 14307c478bd9Sstevel@tonic-gate #define ENV_FLG_NOENVCONFIG 0x0000400000ULL 14317c478bd9Sstevel@tonic-gate #define ENV_FLG_NOLAZY 0x0000800000ULL 14327c478bd9Sstevel@tonic-gate #define ENV_FLG_NOOBJALTER 0x0001000000ULL 14337c478bd9Sstevel@tonic-gate #define ENV_FLG_NOVERSION 0x0002000000ULL 14347c478bd9Sstevel@tonic-gate #define ENV_FLG_PRELOAD 0x0004000000ULL 14357c478bd9Sstevel@tonic-gate #define ENV_FLG_PROFILE 0x0008000000ULL 14367c478bd9Sstevel@tonic-gate #define ENV_FLG_PROFILE_OUTPUT 0x0010000000ULL 14377c478bd9Sstevel@tonic-gate #define ENV_FLG_SIGNAL 0x0020000000ULL 14387c478bd9Sstevel@tonic-gate #define ENV_FLG_TRACE_OBJS 0x0040000000ULL 14397c478bd9Sstevel@tonic-gate #define ENV_FLG_TRACE_PTHS 0x0080000000ULL 14407c478bd9Sstevel@tonic-gate #define ENV_FLG_UNREF 0x0100000000ULL 14417c478bd9Sstevel@tonic-gate #define ENV_FLG_UNUSED 0x0200000000ULL 14427c478bd9Sstevel@tonic-gate #define ENV_FLG_VERBOSE 0x0400000000ULL 14437c478bd9Sstevel@tonic-gate #define ENV_FLG_WARN 0x0800000000ULL 14447c478bd9Sstevel@tonic-gate #define ENV_FLG_NOFLTCONFIG 0x1000000000ULL 1445dffec89cSrie #define ENV_FLG_BIND_LAZY 0x2000000000ULL 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate #ifdef SIEBEL_DISABLE 14487c478bd9Sstevel@tonic-gate #define ENV_FLG_FIX_1 0x8000000000ULL 14497c478bd9Sstevel@tonic-gate #endif 14507c478bd9Sstevel@tonic-gate 14517c478bd9Sstevel@tonic-gate #define SEL_REPLACE 0x0001 14527c478bd9Sstevel@tonic-gate #define SEL_PERMANT 0x0002 14537c478bd9Sstevel@tonic-gate #define SEL_ACT_RT 0x0100 /* setting rtld_flags */ 14547c478bd9Sstevel@tonic-gate #define SEL_ACT_RT2 0x0200 /* setting rtld_flags2 */ 14557c478bd9Sstevel@tonic-gate #define SEL_ACT_STR 0x0400 /* setting string value */ 14567c478bd9Sstevel@tonic-gate #define SEL_ACT_LML 0x0800 /* setting lml_flags */ 14577c478bd9Sstevel@tonic-gate #define SEL_ACT_LMLT 0x1000 /* setting lml_tflags */ 14587c478bd9Sstevel@tonic-gate #define SEL_ACT_SPEC_1 0x2000 /* For FLG_{FLAGS, LIBPATH} */ 14597c478bd9Sstevel@tonic-gate #define SEL_ACT_SPEC_2 0x4000 /* need special handling */ 14607c478bd9Sstevel@tonic-gate 14617c478bd9Sstevel@tonic-gate /* 14627c478bd9Sstevel@tonic-gate * Pattern match an LD_XXXX environment variable. s1 points to the XXXX part 14637c478bd9Sstevel@tonic-gate * and len specifies its length (comparing a strings length before the string 14647c478bd9Sstevel@tonic-gate * itself speed things up). s2 points to the token itself which has already 14657c478bd9Sstevel@tonic-gate * had any leading white-space removed. 14667c478bd9Sstevel@tonic-gate */ 14677c478bd9Sstevel@tonic-gate static void 14687c478bd9Sstevel@tonic-gate ld_generic_env(const char *s1, size_t len, const char *s2, Word *lmflags, 14697c478bd9Sstevel@tonic-gate Word *lmtflags, uint_t env_flags, int aout) 14707c478bd9Sstevel@tonic-gate { 14717c478bd9Sstevel@tonic-gate u_longlong_t variable = 0; 1472*10a4fa49Srie ushort_t select = 0; 1473*10a4fa49Srie const char **str; 1474*10a4fa49Srie Word val = 0; 14757c478bd9Sstevel@tonic-gate 14767c478bd9Sstevel@tonic-gate /* 14777c478bd9Sstevel@tonic-gate * Determine whether we're dealing with a replaceable or permanent 14787c478bd9Sstevel@tonic-gate * string. 14797c478bd9Sstevel@tonic-gate */ 14807c478bd9Sstevel@tonic-gate if (env_flags & ENV_TYP_PERMANT) { 14817c478bd9Sstevel@tonic-gate /* 14827c478bd9Sstevel@tonic-gate * If the string is from a configuration file and defined as 14837c478bd9Sstevel@tonic-gate * permanent, assign it as permanent. 14847c478bd9Sstevel@tonic-gate */ 14857c478bd9Sstevel@tonic-gate select |= SEL_PERMANT; 14867c478bd9Sstevel@tonic-gate } else 14877c478bd9Sstevel@tonic-gate select |= SEL_REPLACE; 14887c478bd9Sstevel@tonic-gate 14897c478bd9Sstevel@tonic-gate /* 14907c478bd9Sstevel@tonic-gate * Parse the variable given. 14917c478bd9Sstevel@tonic-gate * 14927c478bd9Sstevel@tonic-gate * The LD_AUDIT family. 14937c478bd9Sstevel@tonic-gate */ 14947c478bd9Sstevel@tonic-gate if (*s1 == 'A') { 14957c478bd9Sstevel@tonic-gate if ((len == MSG_LD_AUDIT_SIZE) && (strncmp(s1, 14967c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_AUDIT), MSG_LD_AUDIT_SIZE) == 0)) { 14977c478bd9Sstevel@tonic-gate /* 14987c478bd9Sstevel@tonic-gate * Replaceable and permanent audit objects can exist. 14997c478bd9Sstevel@tonic-gate */ 15007c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 1501fa034d7fSseizo if (select & SEL_REPLACE) 1502fa034d7fSseizo str = &rpl_audit; 1503fa034d7fSseizo else { 1504fa034d7fSseizo str = &prm_audit; 1505fa034d7fSseizo rpl_audit = 0; 1506fa034d7fSseizo } 15077c478bd9Sstevel@tonic-gate variable = ENV_FLG_AUDIT; 15087c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_AUDIT_ARGS_SIZE) && 15097c478bd9Sstevel@tonic-gate (strncmp(s1, MSG_ORIG(MSG_LD_AUDIT_ARGS), 15107c478bd9Sstevel@tonic-gate MSG_LD_AUDIT_ARGS_SIZE) == 0)) { 15117c478bd9Sstevel@tonic-gate /* 15127c478bd9Sstevel@tonic-gate * A specialized variable for plt_exit() use, not 15137c478bd9Sstevel@tonic-gate * documented for general use. 15147c478bd9Sstevel@tonic-gate */ 15157c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 15167c478bd9Sstevel@tonic-gate variable = ENV_FLG_AUDIT_ARGS; 15177c478bd9Sstevel@tonic-gate } 15187c478bd9Sstevel@tonic-gate } 15197c478bd9Sstevel@tonic-gate /* 15207c478bd9Sstevel@tonic-gate * The LD_BIND family and LD_BREADTH (historic). 15217c478bd9Sstevel@tonic-gate */ 15227c478bd9Sstevel@tonic-gate else if (*s1 == 'B') { 1523dffec89cSrie if ((len == MSG_LD_BIND_LAZY_SIZE) && (strncmp(s1, 1524dffec89cSrie MSG_ORIG(MSG_LD_BIND_LAZY), 1525dffec89cSrie MSG_LD_BIND_LAZY_SIZE) == 0)) { 1526dffec89cSrie select |= SEL_ACT_RT2; 1527dffec89cSrie val = RT_FL2_BINDLAZY; 1528dffec89cSrie variable = ENV_FLG_BIND_LAZY; 1529dffec89cSrie } else if ((len == MSG_LD_BIND_NOW_SIZE) && (strncmp(s1, 15307c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_BIND_NOW), MSG_LD_BIND_NOW_SIZE) == 0)) { 15317c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT2; 15327c478bd9Sstevel@tonic-gate val = RT_FL2_BINDNOW; 15337c478bd9Sstevel@tonic-gate variable = ENV_FLG_BIND_NOW; 15347c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_BIND_NOT_SIZE) && (strncmp(s1, 15357c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_BIND_NOT), MSG_LD_BIND_NOT_SIZE) == 0)) { 15367c478bd9Sstevel@tonic-gate /* 15377c478bd9Sstevel@tonic-gate * Another trick, enabled to help debug AOUT 15387c478bd9Sstevel@tonic-gate * applications under BCP, but not documented for 15397c478bd9Sstevel@tonic-gate * general use. 15407c478bd9Sstevel@tonic-gate */ 15417c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 15427c478bd9Sstevel@tonic-gate val = RT_FL_NOBIND; 15437c478bd9Sstevel@tonic-gate variable = ENV_FLG_BIND_NOT; 15447c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_BINDINGS_SIZE) && (strncmp(s1, 15457c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_BINDINGS), MSG_LD_BINDINGS_SIZE) == 0)) { 15467c478bd9Sstevel@tonic-gate /* 15477c478bd9Sstevel@tonic-gate * This variable is simply for backward compatibility. 15487c478bd9Sstevel@tonic-gate * If this and LD_DEBUG are both specified, only one of 15497c478bd9Sstevel@tonic-gate * the strings is going to get processed. 15507c478bd9Sstevel@tonic-gate */ 15517c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 15527c478bd9Sstevel@tonic-gate variable = ENV_FLG_BINDINGS; 15537c478bd9Sstevel@tonic-gate #ifndef LD_BREADTH_DISABLED 15547c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_BREADTH_SIZE) && (strncmp(s1, 15557c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_BREADTH), MSG_LD_BREADTH_SIZE) == 0)) { 15567c478bd9Sstevel@tonic-gate /* 15577c478bd9Sstevel@tonic-gate * Besides some old patches this is no longer available. 15587c478bd9Sstevel@tonic-gate */ 15597c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_BREADTH; 15607c478bd9Sstevel@tonic-gate return; 15617c478bd9Sstevel@tonic-gate #endif 15627c478bd9Sstevel@tonic-gate } 15637c478bd9Sstevel@tonic-gate } 15647c478bd9Sstevel@tonic-gate /* 15657c478bd9Sstevel@tonic-gate * LD_CONCURRENCY and LD_CONFIG family. 15667c478bd9Sstevel@tonic-gate */ 15677c478bd9Sstevel@tonic-gate else if (*s1 == 'C') { 15687c478bd9Sstevel@tonic-gate if ((len == MSG_LD_CONCURRENCY_SIZE) && (strncmp(s1, 15697c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_CONCURRENCY), 15707c478bd9Sstevel@tonic-gate MSG_LD_CONCURRENCY_SIZE) == 0)) { 15717c478bd9Sstevel@tonic-gate /* 15727c478bd9Sstevel@tonic-gate * Waiting in the wings, as concurrency checking isn't 15737c478bd9Sstevel@tonic-gate * yet enabled. 15747c478bd9Sstevel@tonic-gate */ 15757c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 15767c478bd9Sstevel@tonic-gate variable = ENV_FLG_CONCURRENCY; 15777c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_CONFGEN_SIZE) && (strncmp(s1, 15787c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_CONFGEN), MSG_LD_CONFGEN_SIZE) == 0)) { 15797c478bd9Sstevel@tonic-gate /* 15807c478bd9Sstevel@tonic-gate * Set by crle(1) to indicate it's building a 15817c478bd9Sstevel@tonic-gate * configuration file, not documented for general use. 15827c478bd9Sstevel@tonic-gate */ 15837c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 15847c478bd9Sstevel@tonic-gate variable = ENV_FLG_CONFGEN; 15857c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_CONFIG_SIZE) && (strncmp(s1, 15867c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_CONFIG), MSG_LD_CONFIG_SIZE) == 0)) { 15877c478bd9Sstevel@tonic-gate /* 15887c478bd9Sstevel@tonic-gate * Secure applications must use a default configuration 15897c478bd9Sstevel@tonic-gate * file. A setting from a configuration file doesn't 15907c478bd9Sstevel@tonic-gate * make sense (given we must be reading a configuration 15917c478bd9Sstevel@tonic-gate * file to have gotten this). 15927c478bd9Sstevel@tonic-gate */ 15937c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SECURE) || 15947c478bd9Sstevel@tonic-gate (env_flags & ENV_TYP_CONFIG)) 15957c478bd9Sstevel@tonic-gate return; 15967c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 15977c478bd9Sstevel@tonic-gate str = &config->c_name; 15987c478bd9Sstevel@tonic-gate variable = ENV_FLG_CONFIG; 15997c478bd9Sstevel@tonic-gate } 16007c478bd9Sstevel@tonic-gate } 16017c478bd9Sstevel@tonic-gate /* 16027c478bd9Sstevel@tonic-gate * The LD_DEBUG family and LD_DEMANGLE. 16037c478bd9Sstevel@tonic-gate */ 16047c478bd9Sstevel@tonic-gate else if (*s1 == 'D') { 16057c478bd9Sstevel@tonic-gate if ((len == MSG_LD_DEBUG_SIZE) && (strncmp(s1, 16067c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_DEBUG), MSG_LD_DEBUG_SIZE) == 0)) { 16077c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 1608fa034d7fSseizo if (select & SEL_REPLACE) 1609fa034d7fSseizo str = &rpl_debug; 1610fa034d7fSseizo else { 1611fa034d7fSseizo str = &prm_debug; 1612fa034d7fSseizo rpl_debug = 0; 1613fa034d7fSseizo } 16147c478bd9Sstevel@tonic-gate variable = ENV_FLG_DEBUG; 16157c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_DEBUG_OUTPUT_SIZE) && (strncmp(s1, 16167c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_DEBUG_OUTPUT), 16177c478bd9Sstevel@tonic-gate MSG_LD_DEBUG_OUTPUT_SIZE) == 0)) { 16187c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 16197c478bd9Sstevel@tonic-gate str = &dbg_file; 16207c478bd9Sstevel@tonic-gate variable = ENV_FLG_DEBUG_OUTPUT; 16217c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_DEMANGLE_SIZE) && (strncmp(s1, 16227c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_DEMANGLE), MSG_LD_DEMANGLE_SIZE) == 0)) { 16237c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 16247c478bd9Sstevel@tonic-gate val = RT_FL_DEMANGLE; 16257c478bd9Sstevel@tonic-gate variable = ENV_FLG_DEMANGLE; 16267c478bd9Sstevel@tonic-gate } 16277c478bd9Sstevel@tonic-gate } 16287c478bd9Sstevel@tonic-gate /* 16297c478bd9Sstevel@tonic-gate * LD_FLAGS - collect the best variable definition. On completion of 16307c478bd9Sstevel@tonic-gate * environment variable processing pass the result to ld_flags_env() 16317c478bd9Sstevel@tonic-gate * where they'll be decomposed and passed back to this routine. 16327c478bd9Sstevel@tonic-gate */ 16337c478bd9Sstevel@tonic-gate else if (*s1 == 'F') { 16347c478bd9Sstevel@tonic-gate if ((len == MSG_LD_FLAGS_SIZE) && (strncmp(s1, 16357c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_FLAGS), MSG_LD_FLAGS_SIZE) == 0)) { 16367c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_1; 1637fa034d7fSseizo if (select & SEL_REPLACE) 1638fa034d7fSseizo str = &rpl_ldflags; 1639fa034d7fSseizo else { 1640fa034d7fSseizo str = &prm_ldflags; 1641fa034d7fSseizo rpl_ldflags = 0; 1642fa034d7fSseizo } 16437c478bd9Sstevel@tonic-gate variable = ENV_FLG_FLAGS; 16447c478bd9Sstevel@tonic-gate } 16457c478bd9Sstevel@tonic-gate } 16467c478bd9Sstevel@tonic-gate /* 16477c478bd9Sstevel@tonic-gate * LD_INIT (internal, used by ldd(1)). 16487c478bd9Sstevel@tonic-gate */ 16497c478bd9Sstevel@tonic-gate else if (*s1 == 'I') { 16507c478bd9Sstevel@tonic-gate if ((len == MSG_LD_INIT_SIZE) && (strncmp(s1, 16517c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_INIT), MSG_LD_INIT_SIZE) == 0)) { 16527c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 16537c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_INIT; 16547c478bd9Sstevel@tonic-gate variable = ENV_FLG_INIT; 16557c478bd9Sstevel@tonic-gate } 16567c478bd9Sstevel@tonic-gate } 16577c478bd9Sstevel@tonic-gate /* 16587c478bd9Sstevel@tonic-gate * The LD_LIBRARY_PATH and LD_LOAD families. 16597c478bd9Sstevel@tonic-gate */ 16607c478bd9Sstevel@tonic-gate else if (*s1 == 'L') { 16617c478bd9Sstevel@tonic-gate if ((len == MSG_LD_LIBPATH_SIZE) && (strncmp(s1, 16627c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_LIBPATH), MSG_LD_LIBPATH_SIZE) == 0)) { 16637c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_1; 1664fa034d7fSseizo if (select & SEL_REPLACE) 1665fa034d7fSseizo str = &rpl_libpath; 1666fa034d7fSseizo else { 1667fa034d7fSseizo str = &prm_libpath; 1668fa034d7fSseizo rpl_libpath = 0; 1669fa034d7fSseizo } 16707c478bd9Sstevel@tonic-gate variable = ENV_FLG_LIBPATH; 16717c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_LOADAVAIL_SIZE) && (strncmp(s1, 16727c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_LOADAVAIL), MSG_LD_LOADAVAIL_SIZE) == 0)) { 16737c478bd9Sstevel@tonic-gate /* 16747c478bd9Sstevel@tonic-gate * Internal use by crle(1), not documented for general 16757c478bd9Sstevel@tonic-gate * use. 16767c478bd9Sstevel@tonic-gate */ 16777c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 16787c478bd9Sstevel@tonic-gate val = LML_FLG_LOADAVAIL; 16797c478bd9Sstevel@tonic-gate variable = ENV_FLG_LOADAVAIL; 16807c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_LOADFLTR_SIZE) && (strncmp(s1, 16817c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_LOADFLTR), MSG_LD_LOADFLTR_SIZE) == 0)) { 16827c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 16837c478bd9Sstevel@tonic-gate variable = ENV_FLG_LOADFLTR; 16847c478bd9Sstevel@tonic-gate } 16857c478bd9Sstevel@tonic-gate } 16867c478bd9Sstevel@tonic-gate /* 16877c478bd9Sstevel@tonic-gate * The LD_NO family. 16887c478bd9Sstevel@tonic-gate */ 16897c478bd9Sstevel@tonic-gate else if (*s1 == 'N') { 16907c478bd9Sstevel@tonic-gate if ((len == MSG_LD_NOAUDIT_SIZE) && (strncmp(s1, 16917c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOAUDIT), MSG_LD_NOAUDIT_SIZE) == 0)) { 16927c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 16937c478bd9Sstevel@tonic-gate val = RT_FL_NOAUDIT; 16947c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOAUDIT; 16957c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOAUXFLTR_SIZE) && (strncmp(s1, 16967c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOAUXFLTR), MSG_LD_NOAUXFLTR_SIZE) == 0)) { 16977c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 16987c478bd9Sstevel@tonic-gate val = RT_FL_NOAUXFLTR; 16997c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOAUXFLTR; 17007c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOBAPLT_SIZE) && (strncmp(s1, 17017c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOBAPLT), MSG_LD_NOBAPLT_SIZE) == 0)) { 17027c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17037c478bd9Sstevel@tonic-gate val = RT_FL_NOBAPLT; 17047c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOBAPLT; 17057c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOCONFIG_SIZE) && (strncmp(s1, 17067c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOCONFIG), MSG_LD_NOCONFIG_SIZE) == 0)) { 17077c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17087c478bd9Sstevel@tonic-gate val = RT_FL_NOCFG; 17097c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOCONFIG; 17107c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NODIRCONFIG_SIZE) && (strncmp(s1, 17117c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NODIRCONFIG), 17127c478bd9Sstevel@tonic-gate MSG_LD_NODIRCONFIG_SIZE) == 0)) { 17137c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17147c478bd9Sstevel@tonic-gate val = RT_FL_NODIRCFG; 17157c478bd9Sstevel@tonic-gate variable = ENV_FLG_NODIRCONFIG; 17167c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NODIRECT_SIZE) && (strncmp(s1, 17177c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NODIRECT), MSG_LD_NODIRECT_SIZE) == 0)) { 17187c478bd9Sstevel@tonic-gate select |= SEL_ACT_LMLT; 17197c478bd9Sstevel@tonic-gate val = LML_TFLG_NODIRECT; 17207c478bd9Sstevel@tonic-gate variable = ENV_FLG_NODIRECT; 17217c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOENVCONFIG_SIZE) && (strncmp(s1, 17227c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOENVCONFIG), 17237c478bd9Sstevel@tonic-gate MSG_LD_NOENVCONFIG_SIZE) == 0)) { 17247c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17257c478bd9Sstevel@tonic-gate val = RT_FL_NOENVCFG; 17267c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOENVCONFIG; 17277c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOFLTCONFIG_SIZE) && (strncmp(s1, 17287c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOFLTCONFIG), 17297c478bd9Sstevel@tonic-gate MSG_LD_NOFLTCONFIG_SIZE) == 0)) { 17307c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT2; 17317c478bd9Sstevel@tonic-gate val = RT_FL2_NOFLTCFG; 17327c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOFLTCONFIG; 17337c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOLAZY_SIZE) && (strncmp(s1, 17347c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOLAZY), MSG_LD_NOLAZY_SIZE) == 0)) { 17357c478bd9Sstevel@tonic-gate select |= SEL_ACT_LMLT; 17367c478bd9Sstevel@tonic-gate val = LML_TFLG_NOLAZYLD; 17377c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOLAZY; 17387c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOOBJALTER_SIZE) && (strncmp(s1, 17397c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOOBJALTER), 17407c478bd9Sstevel@tonic-gate MSG_LD_NOOBJALTER_SIZE) == 0)) { 17417c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17427c478bd9Sstevel@tonic-gate val = RT_FL_NOOBJALT; 17437c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOOBJALTER; 17447c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOVERSION_SIZE) && (strncmp(s1, 17457c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOVERSION), MSG_LD_NOVERSION_SIZE) == 0)) { 17467c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17477c478bd9Sstevel@tonic-gate val = RT_FL_NOVERSION; 17487c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOVERSION; 17497c478bd9Sstevel@tonic-gate } 17507c478bd9Sstevel@tonic-gate } 17517c478bd9Sstevel@tonic-gate /* 17527c478bd9Sstevel@tonic-gate * LD_ORIGIN. 17537c478bd9Sstevel@tonic-gate */ 17547c478bd9Sstevel@tonic-gate else if (*s1 == 'O') { 17557c478bd9Sstevel@tonic-gate #ifndef EXPAND_RELATIVE 17567c478bd9Sstevel@tonic-gate if ((len == MSG_LD_ORIGIN_SIZE) && (strncmp(s1, 17577c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_ORIGIN), MSG_LD_ORIGIN_SIZE) == 0)) { 17587c478bd9Sstevel@tonic-gate /* 17597c478bd9Sstevel@tonic-gate * Besides some old patches this is no longer required. 17607c478bd9Sstevel@tonic-gate */ 17617c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_RELATIVE; 17627c478bd9Sstevel@tonic-gate } 17637c478bd9Sstevel@tonic-gate #endif 17647c478bd9Sstevel@tonic-gate return; 17657c478bd9Sstevel@tonic-gate } 17667c478bd9Sstevel@tonic-gate /* 17677c478bd9Sstevel@tonic-gate * LD_PRELOAD and LD_PROFILE family. 17687c478bd9Sstevel@tonic-gate */ 17697c478bd9Sstevel@tonic-gate else if (*s1 == 'P') { 17707c478bd9Sstevel@tonic-gate if ((len == MSG_LD_PRELOAD_SIZE) && (strncmp(s1, 17717c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_PRELOAD), MSG_LD_PRELOAD_SIZE) == 0)) { 17727c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 1773fa034d7fSseizo if (select & SEL_REPLACE) 1774fa034d7fSseizo str = &rpl_preload; 1775fa034d7fSseizo else { 1776fa034d7fSseizo str = &prm_preload; 1777fa034d7fSseizo rpl_preload = 0; 1778fa034d7fSseizo } 17797c478bd9Sstevel@tonic-gate variable = ENV_FLG_PRELOAD; 17807c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_PROFILE_SIZE) && (strncmp(s1, 17817c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_PROFILE), MSG_LD_PROFILE_SIZE) == 0)) { 17827c478bd9Sstevel@tonic-gate /* 17837c478bd9Sstevel@tonic-gate * Only one user library can be profiled at a time. 17847c478bd9Sstevel@tonic-gate */ 17857c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 17867c478bd9Sstevel@tonic-gate variable = ENV_FLG_PROFILE; 17877c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_PROFILE_OUTPUT_SIZE) && (strncmp(s1, 17887c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_PROFILE_OUTPUT), 17897c478bd9Sstevel@tonic-gate MSG_LD_PROFILE_OUTPUT_SIZE) == 0)) { 17907c478bd9Sstevel@tonic-gate /* 17917c478bd9Sstevel@tonic-gate * Only one user library can be profiled at a time. 17927c478bd9Sstevel@tonic-gate */ 17937c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 17947c478bd9Sstevel@tonic-gate str = &profile_out; 17957c478bd9Sstevel@tonic-gate variable = ENV_FLG_PROFILE_OUTPUT; 17967c478bd9Sstevel@tonic-gate } 17977c478bd9Sstevel@tonic-gate } 17987c478bd9Sstevel@tonic-gate /* 17997c478bd9Sstevel@tonic-gate * LD_SIGNAL. 18007c478bd9Sstevel@tonic-gate */ 18017c478bd9Sstevel@tonic-gate else if (*s1 == 'S') { 18027c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_SECURE) 18037c478bd9Sstevel@tonic-gate return; 18047c478bd9Sstevel@tonic-gate if ((len == MSG_LD_SIGNAL_SIZE) && 18057c478bd9Sstevel@tonic-gate (strncmp(s1, MSG_ORIG(MSG_LD_SIGNAL), 18067c478bd9Sstevel@tonic-gate MSG_LD_SIGNAL_SIZE) == 0)) { 18077c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 18087c478bd9Sstevel@tonic-gate variable = ENV_FLG_SIGNAL; 18097c478bd9Sstevel@tonic-gate } 18107c478bd9Sstevel@tonic-gate } 18117c478bd9Sstevel@tonic-gate /* 18127c478bd9Sstevel@tonic-gate * The LD_TRACE family (internal, used by ldd(1)). 18137c478bd9Sstevel@tonic-gate */ 18147c478bd9Sstevel@tonic-gate else if (*s1 == 'T') { 18157c478bd9Sstevel@tonic-gate if (((len == MSG_LD_TRACE_OBJS_SIZE) && 18167c478bd9Sstevel@tonic-gate (strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS), 18177c478bd9Sstevel@tonic-gate MSG_LD_TRACE_OBJS_SIZE) == 0)) || 18187c478bd9Sstevel@tonic-gate ((len == MSG_LD_TRACE_OBJS_E_SIZE) && 18197c478bd9Sstevel@tonic-gate (((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_E), 18207c478bd9Sstevel@tonic-gate MSG_LD_TRACE_OBJS_E_SIZE) == 0) && !aout) || 18217c478bd9Sstevel@tonic-gate ((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_A), 18227c478bd9Sstevel@tonic-gate MSG_LD_TRACE_OBJS_A_SIZE) == 0) && aout)))) { 18237c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 18247c478bd9Sstevel@tonic-gate variable = ENV_FLG_TRACE_OBJS; 18257c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_TRACE_PTHS_SIZE) && (strncmp(s1, 18267c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_TRACE_PTHS), 18277c478bd9Sstevel@tonic-gate MSG_LD_TRACE_PTHS_SIZE) == 0)) { 18287c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 18297c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_SEARCH; 18307c478bd9Sstevel@tonic-gate variable = ENV_FLG_TRACE_PTHS; 18317c478bd9Sstevel@tonic-gate } 18327c478bd9Sstevel@tonic-gate } 18337c478bd9Sstevel@tonic-gate /* 18347c478bd9Sstevel@tonic-gate * LD_UNREF and LD_UNUSED (internal, used by ldd(1)). 18357c478bd9Sstevel@tonic-gate */ 18367c478bd9Sstevel@tonic-gate else if (*s1 == 'U') { 18377c478bd9Sstevel@tonic-gate if ((len == MSG_LD_UNREF_SIZE) && (strncmp(s1, 18387c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_UNREF), MSG_LD_UNREF_SIZE) == 0)) { 18397c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 18407c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_UNREF; 18417c478bd9Sstevel@tonic-gate variable = ENV_FLG_UNREF; 18427c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_UNUSED_SIZE) && (strncmp(s1, 18437c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_UNUSED), MSG_LD_UNUSED_SIZE) == 0)) { 18447c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 18457c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_UNUSED; 18467c478bd9Sstevel@tonic-gate variable = ENV_FLG_UNUSED; 18477c478bd9Sstevel@tonic-gate } 18487c478bd9Sstevel@tonic-gate } 18497c478bd9Sstevel@tonic-gate /* 18507c478bd9Sstevel@tonic-gate * LD_VERBOSE (internal, used by ldd(1)). 18517c478bd9Sstevel@tonic-gate */ 18527c478bd9Sstevel@tonic-gate else if (*s1 == 'V') { 18537c478bd9Sstevel@tonic-gate if ((len == MSG_LD_VERBOSE_SIZE) && (strncmp(s1, 18547c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_VERBOSE), MSG_LD_VERBOSE_SIZE) == 0)) { 18557c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 18567c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_VERBOSE; 18577c478bd9Sstevel@tonic-gate variable = ENV_FLG_VERBOSE; 18587c478bd9Sstevel@tonic-gate } 18597c478bd9Sstevel@tonic-gate } 18607c478bd9Sstevel@tonic-gate /* 18617c478bd9Sstevel@tonic-gate * LD_WARN (internal, used by ldd(1)). 18627c478bd9Sstevel@tonic-gate */ 18637c478bd9Sstevel@tonic-gate else if (*s1 == 'W') { 18647c478bd9Sstevel@tonic-gate if ((len == MSG_LD_WARN_SIZE) && (strncmp(s1, 18657c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_WARN), MSG_LD_WARN_SIZE) == 0)) { 18667c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 18677c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_WARN; 18687c478bd9Sstevel@tonic-gate variable = ENV_FLG_WARN; 18697c478bd9Sstevel@tonic-gate } 18707c478bd9Sstevel@tonic-gate #ifdef SIEBEL_DISABLE 18717c478bd9Sstevel@tonic-gate } 18727c478bd9Sstevel@tonic-gate /* 18737c478bd9Sstevel@tonic-gate * LD__FIX__ (undocumented, enable future technology that can't be 18747c478bd9Sstevel@tonic-gate * delivered in a patch release). 18757c478bd9Sstevel@tonic-gate */ 18767c478bd9Sstevel@tonic-gate else if (*s1 == '_') { 18777c478bd9Sstevel@tonic-gate if ((len == MSG_LD_FIX_1_SIZE) && (strncmp(s1, 18787c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_FIX_1), MSG_LD_FIX_1_SIZE) == 0)) { 18797c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 18807c478bd9Sstevel@tonic-gate val = RT_FL_DISFIX_1; 18817c478bd9Sstevel@tonic-gate variable = ENV_FLG_FIX_1; 18827c478bd9Sstevel@tonic-gate } 18837c478bd9Sstevel@tonic-gate #endif 18847c478bd9Sstevel@tonic-gate } 18857c478bd9Sstevel@tonic-gate if (variable == 0) 18867c478bd9Sstevel@tonic-gate return; 18877c478bd9Sstevel@tonic-gate 18887c478bd9Sstevel@tonic-gate /* 18897c478bd9Sstevel@tonic-gate * If the variable is already processed with ISA specific variable, 18907c478bd9Sstevel@tonic-gate * no further processing needed. 18917c478bd9Sstevel@tonic-gate */ 18927c478bd9Sstevel@tonic-gate if (((select & SEL_REPLACE) && (rplisa & variable)) || 18937c478bd9Sstevel@tonic-gate ((select & SEL_PERMANT) && (prmisa & variable))) 18947c478bd9Sstevel@tonic-gate return; 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate /* 1897fa034d7fSseizo * Now mark the appropriate variables. 1898fa034d7fSseizo * If the replaceable variable is already set, then the 1899fa034d7fSseizo * process environment variable must be set. Any replaceable 1900fa034d7fSseizo * variable specified in a configuration file can be ignored. 19017c478bd9Sstevel@tonic-gate */ 19027c478bd9Sstevel@tonic-gate if (env_flags & ENV_TYP_ISA) { 19037c478bd9Sstevel@tonic-gate /* 19047c478bd9Sstevel@tonic-gate * This is ISA setting. We do the setting 19057c478bd9Sstevel@tonic-gate * even if s2 is NULL. 19067c478bd9Sstevel@tonic-gate * If s2 is NULL, we might need to undo 19077c478bd9Sstevel@tonic-gate * the setting. 19087c478bd9Sstevel@tonic-gate */ 19097c478bd9Sstevel@tonic-gate if (select & SEL_REPLACE) { 1910fa034d7fSseizo if (rplisa & variable) 1911fa034d7fSseizo return; 19127c478bd9Sstevel@tonic-gate rplisa |= variable; 19137c478bd9Sstevel@tonic-gate } else { 19147c478bd9Sstevel@tonic-gate prmisa |= variable; 19157c478bd9Sstevel@tonic-gate } 19167c478bd9Sstevel@tonic-gate } else if (s2) { 19177c478bd9Sstevel@tonic-gate /* 19187c478bd9Sstevel@tonic-gate * This is non0-ISA setting 19197c478bd9Sstevel@tonic-gate */ 19207c478bd9Sstevel@tonic-gate if (select & SEL_REPLACE) { 1921fa034d7fSseizo if (rplgen & variable) 1922fa034d7fSseizo return; 19237c478bd9Sstevel@tonic-gate rplgen |= variable; 19247c478bd9Sstevel@tonic-gate } else 19257c478bd9Sstevel@tonic-gate prmgen |= variable; 19267c478bd9Sstevel@tonic-gate } else 19277c478bd9Sstevel@tonic-gate /* 19287c478bd9Sstevel@tonic-gate * This is non-ISA setting which 19297c478bd9Sstevel@tonic-gate * can be ignored. 19307c478bd9Sstevel@tonic-gate */ 19317c478bd9Sstevel@tonic-gate return; 19327c478bd9Sstevel@tonic-gate 19337c478bd9Sstevel@tonic-gate /* 19347c478bd9Sstevel@tonic-gate * Now perform the setting. 19357c478bd9Sstevel@tonic-gate */ 19367c478bd9Sstevel@tonic-gate if (select & SEL_ACT_RT) { 19377c478bd9Sstevel@tonic-gate if (s2) 19387c478bd9Sstevel@tonic-gate rtld_flags |= val; 19397c478bd9Sstevel@tonic-gate else 19407c478bd9Sstevel@tonic-gate rtld_flags &= ~val; 19417c478bd9Sstevel@tonic-gate } else if (select & SEL_ACT_RT2) { 19427c478bd9Sstevel@tonic-gate if (s2) 19437c478bd9Sstevel@tonic-gate rtld_flags2 |= val; 19447c478bd9Sstevel@tonic-gate else 19457c478bd9Sstevel@tonic-gate rtld_flags2 &= ~val; 19467c478bd9Sstevel@tonic-gate } else if (select & SEL_ACT_STR) 19477c478bd9Sstevel@tonic-gate *str = s2; 19487c478bd9Sstevel@tonic-gate else if (select & SEL_ACT_LML) { 19497c478bd9Sstevel@tonic-gate if (s2) 19507c478bd9Sstevel@tonic-gate *lmflags |= val; 19517c478bd9Sstevel@tonic-gate else 19527c478bd9Sstevel@tonic-gate *lmflags &= ~val; 19537c478bd9Sstevel@tonic-gate } else if (select & SEL_ACT_LMLT) { 19547c478bd9Sstevel@tonic-gate if (s2) 19557c478bd9Sstevel@tonic-gate *lmtflags |= val; 19567c478bd9Sstevel@tonic-gate else 19577c478bd9Sstevel@tonic-gate *lmtflags &= ~val; 19587c478bd9Sstevel@tonic-gate } else if (select & SEL_ACT_SPEC_1) { 19597c478bd9Sstevel@tonic-gate /* 19607c478bd9Sstevel@tonic-gate * variable is either ENV_FLG_FLAGS or ENV_FLG_LIBPATH 19617c478bd9Sstevel@tonic-gate */ 19627c478bd9Sstevel@tonic-gate *str = s2; 19637c478bd9Sstevel@tonic-gate if ((select & SEL_REPLACE) && (env_flags & ENV_TYP_CONFIG)) { 19647c478bd9Sstevel@tonic-gate if (s2) { 19657c478bd9Sstevel@tonic-gate if (variable == ENV_FLG_FLAGS) 19667c478bd9Sstevel@tonic-gate env_info |= ENV_INF_FLAGCFG; 19677c478bd9Sstevel@tonic-gate else 19687c478bd9Sstevel@tonic-gate env_info |= ENV_INF_PATHCFG; 19697c478bd9Sstevel@tonic-gate } else { 19707c478bd9Sstevel@tonic-gate if (variable == ENV_FLG_FLAGS) 19717c478bd9Sstevel@tonic-gate env_info &= ~ENV_INF_FLAGCFG; 19727c478bd9Sstevel@tonic-gate else 19737c478bd9Sstevel@tonic-gate env_info &= ~ENV_INF_PATHCFG; 19747c478bd9Sstevel@tonic-gate } 19757c478bd9Sstevel@tonic-gate } 19767c478bd9Sstevel@tonic-gate } else if (select & SEL_ACT_SPEC_2) { 19777c478bd9Sstevel@tonic-gate /* 19787c478bd9Sstevel@tonic-gate * variables can be: ENV_FLG_ 19797c478bd9Sstevel@tonic-gate * AUDIT_ARGS, BINDING, CONCURRENCY, CONFGEN, 19807c478bd9Sstevel@tonic-gate * LOADFLTR, PROFILE, SIGNAL, TRACE_OBJS 19817c478bd9Sstevel@tonic-gate */ 19827c478bd9Sstevel@tonic-gate if (variable == ENV_FLG_AUDIT_ARGS) { 19837c478bd9Sstevel@tonic-gate if (s2) { 19847c478bd9Sstevel@tonic-gate audit_argcnt = atoi(s2); 19857c478bd9Sstevel@tonic-gate audit_argcnt += audit_argcnt % 2; 19867c478bd9Sstevel@tonic-gate } else 19877c478bd9Sstevel@tonic-gate audit_argcnt = 0; 19887c478bd9Sstevel@tonic-gate } else if (variable == ENV_FLG_BINDINGS) { 19897c478bd9Sstevel@tonic-gate if (s2) 19907c478bd9Sstevel@tonic-gate rpl_debug = MSG_ORIG(MSG_TKN_BINDINGS); 19917c478bd9Sstevel@tonic-gate else 19927c478bd9Sstevel@tonic-gate rpl_debug = 0; 19937c478bd9Sstevel@tonic-gate } else if (variable == ENV_FLG_CONCURRENCY) { 19947c478bd9Sstevel@tonic-gate if (s2) 19957c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_NOCONCUR; 19967c478bd9Sstevel@tonic-gate else 19977c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_NOCONCUR; 19987c478bd9Sstevel@tonic-gate } else if (variable == ENV_FLG_CONFGEN) { 19997c478bd9Sstevel@tonic-gate if (s2) { 20007c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_CONFGEN; 20017c478bd9Sstevel@tonic-gate *lmflags |= LML_FLG_IGNRELERR; 20027c478bd9Sstevel@tonic-gate } else { 20037c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_CONFGEN; 20047c478bd9Sstevel@tonic-gate *lmflags &= ~LML_FLG_IGNRELERR; 20057c478bd9Sstevel@tonic-gate } 20067c478bd9Sstevel@tonic-gate } else if (variable == ENV_FLG_LOADFLTR) { 20077c478bd9Sstevel@tonic-gate if (s2) { 20087c478bd9Sstevel@tonic-gate *lmtflags |= LML_TFLG_LOADFLTR; 20097c478bd9Sstevel@tonic-gate if (*s2 == '2') 20107c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_WARNFLTR; 20117c478bd9Sstevel@tonic-gate } else { 20127c478bd9Sstevel@tonic-gate *lmtflags &= ~LML_TFLG_LOADFLTR; 20137c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_WARNFLTR; 20147c478bd9Sstevel@tonic-gate } 20157c478bd9Sstevel@tonic-gate } else if (variable == ENV_FLG_PROFILE) { 20167c478bd9Sstevel@tonic-gate profile_name = s2; 20177c478bd9Sstevel@tonic-gate if (s2) { 20187c478bd9Sstevel@tonic-gate if (strcmp(s2, MSG_ORIG(MSG_FIL_RTLD)) == 0) { 20197c478bd9Sstevel@tonic-gate return; 20207c478bd9Sstevel@tonic-gate } 20217c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_SECURE) { 20227c478bd9Sstevel@tonic-gate profile_lib = 20237c478bd9Sstevel@tonic-gate #if defined(_ELF64) 20247c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_LDPROFSE_64); 20257c478bd9Sstevel@tonic-gate #else 20267c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_LDPROFSE); 20277c478bd9Sstevel@tonic-gate #endif 20287c478bd9Sstevel@tonic-gate } else { 20297c478bd9Sstevel@tonic-gate profile_lib = 20307c478bd9Sstevel@tonic-gate #if defined(_ELF64) 20317c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_LDPROF_64); 20327c478bd9Sstevel@tonic-gate #else 20337c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_LDPROF); 20347c478bd9Sstevel@tonic-gate #endif 20357c478bd9Sstevel@tonic-gate } 20367c478bd9Sstevel@tonic-gate } else 20377c478bd9Sstevel@tonic-gate profile_lib = 0; 20387c478bd9Sstevel@tonic-gate } else if (variable == ENV_FLG_SIGNAL) { 20397c478bd9Sstevel@tonic-gate killsig = s2 ? atoi(s2) : SIGKILL; 20407c478bd9Sstevel@tonic-gate } else if (variable == ENV_FLG_TRACE_OBJS) { 20417c478bd9Sstevel@tonic-gate if (s2) { 20427c478bd9Sstevel@tonic-gate *lmflags |= LML_FLG_TRC_ENABLE; 20437c478bd9Sstevel@tonic-gate if (*s2 == '2') 20447c478bd9Sstevel@tonic-gate *lmflags |= LML_FLG_TRC_LDDSTUB; 20457c478bd9Sstevel@tonic-gate } else 20467c478bd9Sstevel@tonic-gate *lmflags &= 20477c478bd9Sstevel@tonic-gate ~(LML_FLG_TRC_ENABLE|LML_FLG_TRC_LDDSTUB); 20487c478bd9Sstevel@tonic-gate } 20497c478bd9Sstevel@tonic-gate } 20507c478bd9Sstevel@tonic-gate } 20517c478bd9Sstevel@tonic-gate 20527c478bd9Sstevel@tonic-gate /* 20537c478bd9Sstevel@tonic-gate * Determine whether we have an architecture specific environment variable. 20547c478bd9Sstevel@tonic-gate * If we do, and we're the wrong architecture, it'll just get ignored. 20557c478bd9Sstevel@tonic-gate * Otherwise the variable is processed in it's architecture neutral form. 20567c478bd9Sstevel@tonic-gate */ 20577c478bd9Sstevel@tonic-gate static int 20587c478bd9Sstevel@tonic-gate ld_arch_env(const char *s1, size_t *len) 20597c478bd9Sstevel@tonic-gate { 20607c478bd9Sstevel@tonic-gate size_t _len = *len - 3; 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate if (s1[_len++] == '_') { 20637c478bd9Sstevel@tonic-gate if ((s1[_len] == '3') && (s1[_len + 1] == '2')) { 20647c478bd9Sstevel@tonic-gate #if defined(_ELF64) 20657c478bd9Sstevel@tonic-gate return (ENV_TYP_IGNORE); 20667c478bd9Sstevel@tonic-gate #else 20677c478bd9Sstevel@tonic-gate *len = *len - 3; 20687c478bd9Sstevel@tonic-gate return (ENV_TYP_ISA); 20697c478bd9Sstevel@tonic-gate #endif 20707c478bd9Sstevel@tonic-gate } 20717c478bd9Sstevel@tonic-gate if ((s1[_len] == '6') && (s1[_len + 1] == '4')) { 20727c478bd9Sstevel@tonic-gate #if defined(_ELF64) 20737c478bd9Sstevel@tonic-gate *len = *len - 3; 20747c478bd9Sstevel@tonic-gate return (ENV_TYP_ISA); 20757c478bd9Sstevel@tonic-gate #else 20767c478bd9Sstevel@tonic-gate return (ENV_TYP_IGNORE); 20777c478bd9Sstevel@tonic-gate #endif 20787c478bd9Sstevel@tonic-gate } 20797c478bd9Sstevel@tonic-gate } 20807c478bd9Sstevel@tonic-gate return (0); 20817c478bd9Sstevel@tonic-gate } 20827c478bd9Sstevel@tonic-gate 20837c478bd9Sstevel@tonic-gate 20847c478bd9Sstevel@tonic-gate /* 20857c478bd9Sstevel@tonic-gate * Process an LD_FLAGS environment variable. The value can be a comma 20867c478bd9Sstevel@tonic-gate * separated set of tokens, which are sent (in upper case) into the generic 20877c478bd9Sstevel@tonic-gate * LD_XXXX environment variable engine. For example: 20887c478bd9Sstevel@tonic-gate * 20897c478bd9Sstevel@tonic-gate * LD_FLAGS=bind_now -> LD_BIND_NOW=1 20907c478bd9Sstevel@tonic-gate * LD_FLAGS=library_path=/foo:. -> LD_LIBRARY_PATH=/foo:. 20917c478bd9Sstevel@tonic-gate * LD_FLAGS=debug=files:detail -> LD_DEBUG=files:detail 20927c478bd9Sstevel@tonic-gate * or 20937c478bd9Sstevel@tonic-gate * LD_FLAGS=bind_now,library_path=/foo:.,debug=files:detail 20947c478bd9Sstevel@tonic-gate */ 20957c478bd9Sstevel@tonic-gate static int 20967c478bd9Sstevel@tonic-gate ld_flags_env(const char *str, Word *lmflags, Word *lmtflags, 20977c478bd9Sstevel@tonic-gate uint_t env_flags, int aout) 20987c478bd9Sstevel@tonic-gate { 20997c478bd9Sstevel@tonic-gate char *nstr, *sstr, *estr = 0; 21007c478bd9Sstevel@tonic-gate size_t nlen, len; 21017c478bd9Sstevel@tonic-gate 21027c478bd9Sstevel@tonic-gate if (str == 0) 21037c478bd9Sstevel@tonic-gate return (0); 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate /* 21067c478bd9Sstevel@tonic-gate * Create a new string as we're going to transform the token(s) into 21077c478bd9Sstevel@tonic-gate * uppercase and separate tokens with nulls. 21087c478bd9Sstevel@tonic-gate */ 21097c478bd9Sstevel@tonic-gate len = strlen(str); 21107c478bd9Sstevel@tonic-gate if ((nstr = malloc(len + 1)) == 0) 21117c478bd9Sstevel@tonic-gate return (1); 21127c478bd9Sstevel@tonic-gate (void) strcpy(nstr, str); 21137c478bd9Sstevel@tonic-gate 21147c478bd9Sstevel@tonic-gate for (sstr = nstr; sstr; sstr++, len--) { 21157c478bd9Sstevel@tonic-gate int flags; 21167c478bd9Sstevel@tonic-gate 21177c478bd9Sstevel@tonic-gate if ((*sstr != '\0') && (*sstr != ',')) { 21187c478bd9Sstevel@tonic-gate if (estr == 0) { 21197c478bd9Sstevel@tonic-gate if (*sstr == '=') 21207c478bd9Sstevel@tonic-gate estr = sstr; 21217c478bd9Sstevel@tonic-gate else { 21227c478bd9Sstevel@tonic-gate /* 21237c478bd9Sstevel@tonic-gate * Translate token to uppercase. Don't 21247c478bd9Sstevel@tonic-gate * use toupper(3C) as including this 21257c478bd9Sstevel@tonic-gate * code doubles the size of ld.so.1. 21267c478bd9Sstevel@tonic-gate */ 21277c478bd9Sstevel@tonic-gate if ((*sstr >= 'a') && (*sstr <= 'z')) 21287c478bd9Sstevel@tonic-gate *sstr = *sstr - ('a' - 'A'); 21297c478bd9Sstevel@tonic-gate } 21307c478bd9Sstevel@tonic-gate } 21317c478bd9Sstevel@tonic-gate continue; 21327c478bd9Sstevel@tonic-gate } 21337c478bd9Sstevel@tonic-gate 21347c478bd9Sstevel@tonic-gate *sstr = '\0'; 21357c478bd9Sstevel@tonic-gate if (estr) { 21367c478bd9Sstevel@tonic-gate nlen = estr - nstr; 21377c478bd9Sstevel@tonic-gate if ((*++estr == '\0') || (*estr == ',')) 21387c478bd9Sstevel@tonic-gate estr = 0; 21397c478bd9Sstevel@tonic-gate } else 21407c478bd9Sstevel@tonic-gate nlen = sstr - nstr; 21417c478bd9Sstevel@tonic-gate 21427c478bd9Sstevel@tonic-gate /* 21437c478bd9Sstevel@tonic-gate * Fabricate a boolean definition for any unqualified variable. 21447c478bd9Sstevel@tonic-gate * Thus LD_FLAGS=bind_now is represented as BIND_NOW=(null). 21457c478bd9Sstevel@tonic-gate * The value is sufficient to assert any boolean variables, plus 21467c478bd9Sstevel@tonic-gate * the term "(null)" is specifically chosen in case someone 21477c478bd9Sstevel@tonic-gate * mistakenly supplies something like LD_FLAGS=library_path. 21487c478bd9Sstevel@tonic-gate */ 21497c478bd9Sstevel@tonic-gate if (estr == 0) 21507c478bd9Sstevel@tonic-gate estr = (char *)MSG_INTL(MSG_STR_NULL); 21517c478bd9Sstevel@tonic-gate 21527c478bd9Sstevel@tonic-gate /* 21537c478bd9Sstevel@tonic-gate * Determine whether the environment variable is 32- or 64-bit 21547c478bd9Sstevel@tonic-gate * specific. The length, len, will reflect the architecture 21557c478bd9Sstevel@tonic-gate * neutral portion of the string. 21567c478bd9Sstevel@tonic-gate */ 21577c478bd9Sstevel@tonic-gate if ((flags = ld_arch_env(nstr, &nlen)) != ENV_TYP_IGNORE) { 21587c478bd9Sstevel@tonic-gate ld_generic_env(nstr, nlen, estr, lmflags, 21597c478bd9Sstevel@tonic-gate lmtflags, (env_flags | flags), aout); 21607c478bd9Sstevel@tonic-gate } 21617c478bd9Sstevel@tonic-gate if (len == 0) 21627c478bd9Sstevel@tonic-gate return (0); 21637c478bd9Sstevel@tonic-gate 21647c478bd9Sstevel@tonic-gate nstr = sstr + 1; 21657c478bd9Sstevel@tonic-gate estr = 0; 21667c478bd9Sstevel@tonic-gate } 21677c478bd9Sstevel@tonic-gate return (0); 21687c478bd9Sstevel@tonic-gate } 21697c478bd9Sstevel@tonic-gate 21707c478bd9Sstevel@tonic-gate 21717c478bd9Sstevel@tonic-gate /* 21727c478bd9Sstevel@tonic-gate * Process a single environment string. Only strings starting with `LD_' are 21737c478bd9Sstevel@tonic-gate * reserved for our use. By convention, all strings should be of the form 21747c478bd9Sstevel@tonic-gate * `LD_XXXX=', if the string is followed by a non-null value the appropriate 21757c478bd9Sstevel@tonic-gate * functionality is enabled. Also pick off applicable locale variables. 21767c478bd9Sstevel@tonic-gate */ 21777c478bd9Sstevel@tonic-gate #define LOC_LANG 1 21787c478bd9Sstevel@tonic-gate #define LOC_MESG 2 21797c478bd9Sstevel@tonic-gate #define LOC_ALL 3 21807c478bd9Sstevel@tonic-gate 21817c478bd9Sstevel@tonic-gate static void 21827c478bd9Sstevel@tonic-gate ld_str_env(const char *s1, Word *lmflags, Word *lmtflags, uint_t env_flags, 21837c478bd9Sstevel@tonic-gate int aout) 21847c478bd9Sstevel@tonic-gate { 21857c478bd9Sstevel@tonic-gate const char *s2; 2186*10a4fa49Srie static size_t loc = 0; 21877c478bd9Sstevel@tonic-gate 21887c478bd9Sstevel@tonic-gate if (*s1++ != 'L') 21897c478bd9Sstevel@tonic-gate return; 21907c478bd9Sstevel@tonic-gate 21917c478bd9Sstevel@tonic-gate /* 21927c478bd9Sstevel@tonic-gate * See if we have any locale environment settings. These environment 21937c478bd9Sstevel@tonic-gate * variables have a precedence, LC_ALL is higher than LC_MESSAGES which 21947c478bd9Sstevel@tonic-gate * is higher than LANG. 21957c478bd9Sstevel@tonic-gate */ 21967c478bd9Sstevel@tonic-gate s2 = s1; 21977c478bd9Sstevel@tonic-gate if ((*s2++ == 'C') && (*s2++ == '_') && (*s2 != '\0')) { 21987c478bd9Sstevel@tonic-gate if (strncmp(s2, MSG_ORIG(MSG_LC_ALL), MSG_LC_ALL_SIZE) == 0) { 21997c478bd9Sstevel@tonic-gate s2 += MSG_LC_ALL_SIZE; 22007c478bd9Sstevel@tonic-gate if ((*s2 != '\0') && (loc < LOC_ALL)) { 2201*10a4fa49Srie glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2; 22027c478bd9Sstevel@tonic-gate loc = LOC_ALL; 22037c478bd9Sstevel@tonic-gate } 22047c478bd9Sstevel@tonic-gate } else if (strncmp(s2, MSG_ORIG(MSG_LC_MESSAGES), 22057c478bd9Sstevel@tonic-gate MSG_LC_MESSAGES_SIZE) == 0) { 22067c478bd9Sstevel@tonic-gate s2 += MSG_LC_MESSAGES_SIZE; 22077c478bd9Sstevel@tonic-gate if ((*s2 != '\0') && (loc < LOC_MESG)) { 2208*10a4fa49Srie glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2; 22097c478bd9Sstevel@tonic-gate loc = LOC_MESG; 22107c478bd9Sstevel@tonic-gate } 22117c478bd9Sstevel@tonic-gate } 22127c478bd9Sstevel@tonic-gate return; 22137c478bd9Sstevel@tonic-gate } 22147c478bd9Sstevel@tonic-gate 22157c478bd9Sstevel@tonic-gate s2 = s1; 22167c478bd9Sstevel@tonic-gate if ((*s2++ == 'A') && (*s2++ == 'N') && (*s2++ == 'G') && 22177c478bd9Sstevel@tonic-gate (*s2++ == '=') && (*s2 != '\0') && (loc < LOC_LANG)) { 2218*10a4fa49Srie glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2; 22197c478bd9Sstevel@tonic-gate loc = LOC_LANG; 22207c478bd9Sstevel@tonic-gate return; 22217c478bd9Sstevel@tonic-gate } 22227c478bd9Sstevel@tonic-gate 22237c478bd9Sstevel@tonic-gate /* 22247c478bd9Sstevel@tonic-gate * Pick off any LD_XXXX environment variables. 22257c478bd9Sstevel@tonic-gate */ 22267c478bd9Sstevel@tonic-gate if ((*s1++ == 'D') && (*s1++ == '_') && (*s1 != '\0')) { 22277c478bd9Sstevel@tonic-gate size_t len; 22287c478bd9Sstevel@tonic-gate int flags; 22297c478bd9Sstevel@tonic-gate 22307c478bd9Sstevel@tonic-gate /* 22317c478bd9Sstevel@tonic-gate * Environment variables with no value (ie. LD_XXXX=) typically 22327c478bd9Sstevel@tonic-gate * have no impact, however if environment variables are defined 22337c478bd9Sstevel@tonic-gate * within a configuration file, these null user settings can be 22347c478bd9Sstevel@tonic-gate * used to disable any configuration replaceable definitions. 22357c478bd9Sstevel@tonic-gate */ 22367c478bd9Sstevel@tonic-gate if ((s2 = strchr(s1, '=')) == 0) { 22377c478bd9Sstevel@tonic-gate len = strlen(s1); 22387c478bd9Sstevel@tonic-gate s2 = 0; 22397c478bd9Sstevel@tonic-gate } else if (*++s2 == '\0') { 22407c478bd9Sstevel@tonic-gate len = strlen(s1) - 1; 22417c478bd9Sstevel@tonic-gate s2 = 0; 22427c478bd9Sstevel@tonic-gate } else { 22437c478bd9Sstevel@tonic-gate len = s2 - s1 - 1; 22447c478bd9Sstevel@tonic-gate while (isspace(*s2)) 22457c478bd9Sstevel@tonic-gate s2++; 22467c478bd9Sstevel@tonic-gate } 22477c478bd9Sstevel@tonic-gate 22487c478bd9Sstevel@tonic-gate /* 22497c478bd9Sstevel@tonic-gate * Determine whether the environment variable is 32- or 64-bit 22507c478bd9Sstevel@tonic-gate * specific. The length, len, will reflect the architecture 22517c478bd9Sstevel@tonic-gate * neutral portion of the string. 22527c478bd9Sstevel@tonic-gate */ 22537c478bd9Sstevel@tonic-gate if ((flags = ld_arch_env(s1, &len)) == ENV_TYP_IGNORE) 22547c478bd9Sstevel@tonic-gate return; 22557c478bd9Sstevel@tonic-gate env_flags |= flags; 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate ld_generic_env(s1, len, s2, lmflags, lmtflags, env_flags, aout); 22587c478bd9Sstevel@tonic-gate } 22597c478bd9Sstevel@tonic-gate } 22607c478bd9Sstevel@tonic-gate 22617c478bd9Sstevel@tonic-gate /* 22627c478bd9Sstevel@tonic-gate * Internal getenv routine. Called immediately after ld.so.1 initializes 22637c478bd9Sstevel@tonic-gate * itself. 22647c478bd9Sstevel@tonic-gate */ 22657c478bd9Sstevel@tonic-gate int 22667c478bd9Sstevel@tonic-gate readenv_user(const char ** envp, Word *lmflags, Word *lmtflags, int aout) 22677c478bd9Sstevel@tonic-gate { 2268*10a4fa49Srie char *locale; 2269*10a4fa49Srie 22707c478bd9Sstevel@tonic-gate if (envp == (const char **)0) 22717c478bd9Sstevel@tonic-gate return (0); 22727c478bd9Sstevel@tonic-gate 22737c478bd9Sstevel@tonic-gate while (*envp != (const char *)0) 22747c478bd9Sstevel@tonic-gate ld_str_env(*envp++, lmflags, lmtflags, 0, aout); 22757c478bd9Sstevel@tonic-gate 22767c478bd9Sstevel@tonic-gate /* 22777c478bd9Sstevel@tonic-gate * Having collected the best representation of any LD_FLAGS, process 22787c478bd9Sstevel@tonic-gate * these strings. 22797c478bd9Sstevel@tonic-gate */ 22807c478bd9Sstevel@tonic-gate if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1) 22817c478bd9Sstevel@tonic-gate return (1); 22827c478bd9Sstevel@tonic-gate 22837c478bd9Sstevel@tonic-gate /* 22847c478bd9Sstevel@tonic-gate * Don't allow environment controlled auditing when tracing or if 22857c478bd9Sstevel@tonic-gate * explicitly disabled. Trigger all tracing modes from 22867c478bd9Sstevel@tonic-gate * LML_FLG_TRC_ENABLE. 22877c478bd9Sstevel@tonic-gate */ 22887c478bd9Sstevel@tonic-gate if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT)) 22897c478bd9Sstevel@tonic-gate rpl_audit = profile_lib = profile_name = 0; 22907c478bd9Sstevel@tonic-gate if ((*lmflags & LML_FLG_TRC_ENABLE) == 0) 22917c478bd9Sstevel@tonic-gate *lmflags &= ~LML_MSK_TRC; 22927c478bd9Sstevel@tonic-gate 2293dffec89cSrie /* 2294dffec89cSrie * If both LD_BIND_NOW and LD_BIND_LAZY are specified, the former wins. 2295dffec89cSrie */ 2296dffec89cSrie if ((rtld_flags2 & (RT_FL2_BINDNOW | RT_FL2_BINDLAZY)) == 2297dffec89cSrie (RT_FL2_BINDNOW | RT_FL2_BINDLAZY)) 2298dffec89cSrie rtld_flags2 &= ~RT_FL2_BINDLAZY; 2299dffec89cSrie 23007c478bd9Sstevel@tonic-gate /* 23017c478bd9Sstevel@tonic-gate * If we have a locale setting make sure its worth processing further. 23027c478bd9Sstevel@tonic-gate * Duplicate the string so that new locale setting can generically 23037c478bd9Sstevel@tonic-gate * cleanup any previous locales. 23047c478bd9Sstevel@tonic-gate */ 2305*10a4fa49Srie if ((locale = glcs[CI_LCMESSAGES].lc_un.lc_ptr) != 0) { 23067c478bd9Sstevel@tonic-gate if (((*locale == 'C') && (*(locale + 1) == '\0')) || 23077c478bd9Sstevel@tonic-gate (strcmp(locale, MSG_ORIG(MSG_TKN_POSIX)) == 0)) 2308*10a4fa49Srie glcs[CI_LCMESSAGES].lc_un.lc_ptr = 0; 23097c478bd9Sstevel@tonic-gate else 2310*10a4fa49Srie glcs[CI_LCMESSAGES].lc_un.lc_ptr = strdup(locale); 23117c478bd9Sstevel@tonic-gate } 23127c478bd9Sstevel@tonic-gate return (0); 23137c478bd9Sstevel@tonic-gate } 23147c478bd9Sstevel@tonic-gate 23157c478bd9Sstevel@tonic-gate /* 23167c478bd9Sstevel@tonic-gate * Configuration environment processing. Called after the a.out has been 23177c478bd9Sstevel@tonic-gate * processed (as the a.out can specify its own configuration file). 23187c478bd9Sstevel@tonic-gate */ 23197c478bd9Sstevel@tonic-gate int 23207c478bd9Sstevel@tonic-gate readenv_config(Rtc_env * envtbl, Addr addr, int aout) 23217c478bd9Sstevel@tonic-gate { 23227c478bd9Sstevel@tonic-gate Word * lmflags = &(lml_main.lm_flags); 23237c478bd9Sstevel@tonic-gate Word * lmtflags = &(lml_main.lm_tflags); 23247c478bd9Sstevel@tonic-gate 23257c478bd9Sstevel@tonic-gate if (envtbl == (Rtc_env *)0) 23267c478bd9Sstevel@tonic-gate return (0); 23277c478bd9Sstevel@tonic-gate 23287c478bd9Sstevel@tonic-gate while (envtbl->env_str) { 23297c478bd9Sstevel@tonic-gate uint_t env_flags = ENV_TYP_CONFIG; 23307c478bd9Sstevel@tonic-gate 23317c478bd9Sstevel@tonic-gate if (envtbl->env_flags & RTC_ENV_PERMANT) 23327c478bd9Sstevel@tonic-gate env_flags |= ENV_TYP_PERMANT; 23337c478bd9Sstevel@tonic-gate 23347c478bd9Sstevel@tonic-gate ld_str_env((const char *)(envtbl->env_str + addr), 23357c478bd9Sstevel@tonic-gate lmflags, lmtflags, env_flags, 0); 23367c478bd9Sstevel@tonic-gate envtbl++; 23377c478bd9Sstevel@tonic-gate } 23387c478bd9Sstevel@tonic-gate 23397c478bd9Sstevel@tonic-gate /* 23407c478bd9Sstevel@tonic-gate * Having collected the best representation of any LD_FLAGS, process 23417c478bd9Sstevel@tonic-gate * these strings. 23427c478bd9Sstevel@tonic-gate */ 23437c478bd9Sstevel@tonic-gate if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1) 23447c478bd9Sstevel@tonic-gate return (1); 23457c478bd9Sstevel@tonic-gate if (ld_flags_env(prm_ldflags, lmflags, lmtflags, ENV_TYP_CONFIG, 23467c478bd9Sstevel@tonic-gate aout) == 1) 23477c478bd9Sstevel@tonic-gate return (1); 23487c478bd9Sstevel@tonic-gate 23497c478bd9Sstevel@tonic-gate /* 23507c478bd9Sstevel@tonic-gate * Don't allow environment controlled auditing when tracing or if 23517c478bd9Sstevel@tonic-gate * explicitly disabled. Trigger all tracing modes from 23527c478bd9Sstevel@tonic-gate * LML_FLG_TRC_ENABLE. 23537c478bd9Sstevel@tonic-gate */ 23547c478bd9Sstevel@tonic-gate if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT)) 23557c478bd9Sstevel@tonic-gate prm_audit = profile_lib = profile_name = 0; 23567c478bd9Sstevel@tonic-gate if ((*lmflags & LML_FLG_TRC_ENABLE) == 0) 23577c478bd9Sstevel@tonic-gate *lmflags &= ~LML_MSK_TRC; 23587c478bd9Sstevel@tonic-gate 23597c478bd9Sstevel@tonic-gate return (0); 23607c478bd9Sstevel@tonic-gate } 23617c478bd9Sstevel@tonic-gate 23627c478bd9Sstevel@tonic-gate int 23637c478bd9Sstevel@tonic-gate dowrite(Prfbuf * prf) 23647c478bd9Sstevel@tonic-gate { 23657c478bd9Sstevel@tonic-gate /* 23667c478bd9Sstevel@tonic-gate * We do not have a valid file descriptor, so we are unable 23677c478bd9Sstevel@tonic-gate * to flush the buffer. 23687c478bd9Sstevel@tonic-gate */ 23697c478bd9Sstevel@tonic-gate if (prf->pr_fd == -1) 23707c478bd9Sstevel@tonic-gate return (0); 23717c478bd9Sstevel@tonic-gate (void) write(prf->pr_fd, prf->pr_buf, prf->pr_cur - prf->pr_buf); 23727c478bd9Sstevel@tonic-gate prf->pr_cur = prf->pr_buf; 23737c478bd9Sstevel@tonic-gate return (1); 23747c478bd9Sstevel@tonic-gate } 23757c478bd9Sstevel@tonic-gate 23767c478bd9Sstevel@tonic-gate /* 23777c478bd9Sstevel@tonic-gate * Simplified printing. The following conversion specifications are supported: 23787c478bd9Sstevel@tonic-gate * 23797c478bd9Sstevel@tonic-gate * % [#] [-] [min field width] [. precision] s|d|x|c 23807c478bd9Sstevel@tonic-gate * 23817c478bd9Sstevel@tonic-gate * 23827c478bd9Sstevel@tonic-gate * dorprf takes the output buffer in the form of Prfbuf which permits 23837c478bd9Sstevel@tonic-gate * the verification of the output buffer size and the concatenation 23847c478bd9Sstevel@tonic-gate * of data to an already existing output buffer. The Prfbuf 23857c478bd9Sstevel@tonic-gate * structure contains the following: 23867c478bd9Sstevel@tonic-gate * 23877c478bd9Sstevel@tonic-gate * pr_buf pointer to the beginning of the output buffer. 23887c478bd9Sstevel@tonic-gate * pr_cur pointer to the next available byte in the output buffer. By 23897c478bd9Sstevel@tonic-gate * setting pr_cur ahead of pr_buf you can append to an already 23907c478bd9Sstevel@tonic-gate * existing buffer. 23917c478bd9Sstevel@tonic-gate * pr_len the size of the output buffer. By setting pr_len to '0' you 23927c478bd9Sstevel@tonic-gate * disable protection from overflows in the output buffer. 23937c478bd9Sstevel@tonic-gate * pr_fd a pointer to the file-descriptor the buffer will eventually be 23947c478bd9Sstevel@tonic-gate * output to. If pr_fd is set to '-1' then it's assumed there is 23957c478bd9Sstevel@tonic-gate * no output buffer and doprf() will return with an error if the 23967c478bd9Sstevel@tonic-gate * output buffer is overflowed. If pr_fd is > -1 then when the 23977c478bd9Sstevel@tonic-gate * output buffer is filled it will be flushed to pr_fd and then 23987c478bd9Sstevel@tonic-gate * the available for additional data. 23997c478bd9Sstevel@tonic-gate */ 24007c478bd9Sstevel@tonic-gate #define FLG_UT_MINUS 0x0001 /* - */ 24017c478bd9Sstevel@tonic-gate #define FLG_UT_SHARP 0x0002 /* # */ 24027c478bd9Sstevel@tonic-gate #define FLG_UT_DOTSEEN 0x0008 /* dot appeared in format spec */ 24037c478bd9Sstevel@tonic-gate 24047c478bd9Sstevel@tonic-gate /* 2405*10a4fa49Srie * This macro is for use from within doprf only. It is to be used for checking 2406*10a4fa49Srie * the output buffer size and placing characters into the buffer. 24077c478bd9Sstevel@tonic-gate */ 24087c478bd9Sstevel@tonic-gate #define PUTC(c) \ 24097c478bd9Sstevel@tonic-gate { \ 2410*10a4fa49Srie char tmpc; \ 24117c478bd9Sstevel@tonic-gate \ 24127c478bd9Sstevel@tonic-gate tmpc = (c); \ 2413*10a4fa49Srie if (bufsiz && (bp >= bufend)) { \ 24147c478bd9Sstevel@tonic-gate prf->pr_cur = bp; \ 24157c478bd9Sstevel@tonic-gate if (dowrite(prf) == 0) \ 24167c478bd9Sstevel@tonic-gate return (0); \ 24177c478bd9Sstevel@tonic-gate bp = prf->pr_cur; \ 24187c478bd9Sstevel@tonic-gate } \ 24197c478bd9Sstevel@tonic-gate *bp++ = tmpc; \ 24207c478bd9Sstevel@tonic-gate } 24217c478bd9Sstevel@tonic-gate 24227c478bd9Sstevel@tonic-gate size_t 24237c478bd9Sstevel@tonic-gate doprf(const char *format, va_list args, Prfbuf *prf) 24247c478bd9Sstevel@tonic-gate { 24257c478bd9Sstevel@tonic-gate char c; 24267c478bd9Sstevel@tonic-gate char *bp = prf->pr_cur; 24277c478bd9Sstevel@tonic-gate char *bufend = prf->pr_buf + prf->pr_len; 24287c478bd9Sstevel@tonic-gate size_t bufsiz = prf->pr_len; 24297c478bd9Sstevel@tonic-gate 24307c478bd9Sstevel@tonic-gate while ((c = *format++) != '\0') { 24317c478bd9Sstevel@tonic-gate if (c != '%') { 24327c478bd9Sstevel@tonic-gate PUTC(c); 24337c478bd9Sstevel@tonic-gate } else { 24347c478bd9Sstevel@tonic-gate int base = 0, flag = 0, width = 0, prec = 0; 24357c478bd9Sstevel@tonic-gate size_t _i; 24367c478bd9Sstevel@tonic-gate int _c, _n; 24377c478bd9Sstevel@tonic-gate char *_s; 24387c478bd9Sstevel@tonic-gate int ls = 0; 24397c478bd9Sstevel@tonic-gate again: 24407c478bd9Sstevel@tonic-gate c = *format++; 24417c478bd9Sstevel@tonic-gate switch (c) { 24427c478bd9Sstevel@tonic-gate case '-': 24437c478bd9Sstevel@tonic-gate flag |= FLG_UT_MINUS; 24447c478bd9Sstevel@tonic-gate goto again; 24457c478bd9Sstevel@tonic-gate case '#': 24467c478bd9Sstevel@tonic-gate flag |= FLG_UT_SHARP; 24477c478bd9Sstevel@tonic-gate goto again; 24487c478bd9Sstevel@tonic-gate case '.': 24497c478bd9Sstevel@tonic-gate flag |= FLG_UT_DOTSEEN; 24507c478bd9Sstevel@tonic-gate goto again; 24517c478bd9Sstevel@tonic-gate case '0': 24527c478bd9Sstevel@tonic-gate case '1': 24537c478bd9Sstevel@tonic-gate case '2': 24547c478bd9Sstevel@tonic-gate case '3': 24557c478bd9Sstevel@tonic-gate case '4': 24567c478bd9Sstevel@tonic-gate case '5': 24577c478bd9Sstevel@tonic-gate case '6': 24587c478bd9Sstevel@tonic-gate case '7': 24597c478bd9Sstevel@tonic-gate case '8': 24607c478bd9Sstevel@tonic-gate case '9': 24617c478bd9Sstevel@tonic-gate if (flag & FLG_UT_DOTSEEN) 24627c478bd9Sstevel@tonic-gate prec = (prec * 10) + c - '0'; 24637c478bd9Sstevel@tonic-gate else 24647c478bd9Sstevel@tonic-gate width = (width * 10) + c - '0'; 24657c478bd9Sstevel@tonic-gate goto again; 24667c478bd9Sstevel@tonic-gate case 'x': 24677c478bd9Sstevel@tonic-gate case 'X': 24687c478bd9Sstevel@tonic-gate base = 16; 24697c478bd9Sstevel@tonic-gate break; 24707c478bd9Sstevel@tonic-gate case 'd': 24717c478bd9Sstevel@tonic-gate case 'D': 24727c478bd9Sstevel@tonic-gate case 'u': 24737c478bd9Sstevel@tonic-gate base = 10; 24747c478bd9Sstevel@tonic-gate flag &= ~FLG_UT_SHARP; 24757c478bd9Sstevel@tonic-gate break; 24767c478bd9Sstevel@tonic-gate case 'l': 24777c478bd9Sstevel@tonic-gate base = 10; 24787c478bd9Sstevel@tonic-gate ls++; /* number of l's (long or long long) */ 24797c478bd9Sstevel@tonic-gate if ((*format == 'l') || 24807c478bd9Sstevel@tonic-gate (*format == 'd') || (*format == 'D') || 24817c478bd9Sstevel@tonic-gate (*format == 'x') || (*format == 'X') || 24827c478bd9Sstevel@tonic-gate (*format == 'o') || (*format == 'O')) 24837c478bd9Sstevel@tonic-gate goto again; 24847c478bd9Sstevel@tonic-gate break; 24857c478bd9Sstevel@tonic-gate case 'o': 24867c478bd9Sstevel@tonic-gate case 'O': 24877c478bd9Sstevel@tonic-gate base = 8; 24887c478bd9Sstevel@tonic-gate break; 24897c478bd9Sstevel@tonic-gate case 'c': 24907c478bd9Sstevel@tonic-gate _c = va_arg(args, int); 24917c478bd9Sstevel@tonic-gate 24927c478bd9Sstevel@tonic-gate for (_i = 24; _i > 0; _i -= 8) { 24937c478bd9Sstevel@tonic-gate if ((c = ((_c >> _i) & 0x7f)) != 0) { 24947c478bd9Sstevel@tonic-gate PUTC(c); 24957c478bd9Sstevel@tonic-gate } 24967c478bd9Sstevel@tonic-gate } 24977c478bd9Sstevel@tonic-gate if ((c = ((_c >> _i) & 0x7f)) != 0) { 24987c478bd9Sstevel@tonic-gate PUTC(c); 24997c478bd9Sstevel@tonic-gate } 25007c478bd9Sstevel@tonic-gate break; 25017c478bd9Sstevel@tonic-gate case 's': 25027c478bd9Sstevel@tonic-gate _s = va_arg(args, char *); 25037c478bd9Sstevel@tonic-gate _i = strlen(_s); 25047c478bd9Sstevel@tonic-gate /* LINTED */ 25057c478bd9Sstevel@tonic-gate _n = (int)(width - _i); 25067c478bd9Sstevel@tonic-gate if (!prec) 25077c478bd9Sstevel@tonic-gate /* LINTED */ 25087c478bd9Sstevel@tonic-gate prec = (int)_i; 25097c478bd9Sstevel@tonic-gate 25107c478bd9Sstevel@tonic-gate if (width && !(flag & FLG_UT_MINUS)) { 25117c478bd9Sstevel@tonic-gate while (_n-- > 0) 25127c478bd9Sstevel@tonic-gate PUTC(' '); 25137c478bd9Sstevel@tonic-gate } 25147c478bd9Sstevel@tonic-gate while (((c = *_s++) != 0) && prec--) { 25157c478bd9Sstevel@tonic-gate PUTC(c); 25167c478bd9Sstevel@tonic-gate } 25177c478bd9Sstevel@tonic-gate if (width && (flag & FLG_UT_MINUS)) { 25187c478bd9Sstevel@tonic-gate while (_n-- > 0) 25197c478bd9Sstevel@tonic-gate PUTC(' '); 25207c478bd9Sstevel@tonic-gate } 25217c478bd9Sstevel@tonic-gate break; 25227c478bd9Sstevel@tonic-gate case '%': 25237c478bd9Sstevel@tonic-gate PUTC('%'); 25247c478bd9Sstevel@tonic-gate break; 25257c478bd9Sstevel@tonic-gate default: 25267c478bd9Sstevel@tonic-gate break; 25277c478bd9Sstevel@tonic-gate } 25287c478bd9Sstevel@tonic-gate 25297c478bd9Sstevel@tonic-gate /* 25307c478bd9Sstevel@tonic-gate * Numeric processing 25317c478bd9Sstevel@tonic-gate */ 25327c478bd9Sstevel@tonic-gate if (base) { 25337c478bd9Sstevel@tonic-gate char local[20]; 25347c478bd9Sstevel@tonic-gate const char *string = 25357c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_HEXNUM); 25367c478bd9Sstevel@tonic-gate size_t ssize = 0, psize = 0; 25377c478bd9Sstevel@tonic-gate const char *prefix = 25387c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY); 25397c478bd9Sstevel@tonic-gate u_longlong_t num; 25407c478bd9Sstevel@tonic-gate 25417c478bd9Sstevel@tonic-gate switch (ls) { 25427c478bd9Sstevel@tonic-gate case 0: /* int */ 25437c478bd9Sstevel@tonic-gate num = (u_longlong_t) 25447c478bd9Sstevel@tonic-gate va_arg(args, uint_t); 25457c478bd9Sstevel@tonic-gate break; 25467c478bd9Sstevel@tonic-gate case 1: /* long */ 25477c478bd9Sstevel@tonic-gate num = (u_longlong_t) 25487c478bd9Sstevel@tonic-gate va_arg(args, ulong_t); 25497c478bd9Sstevel@tonic-gate break; 25507c478bd9Sstevel@tonic-gate case 2: /* long long */ 25517c478bd9Sstevel@tonic-gate num = va_arg(args, u_longlong_t); 25527c478bd9Sstevel@tonic-gate break; 25537c478bd9Sstevel@tonic-gate } 25547c478bd9Sstevel@tonic-gate 25557c478bd9Sstevel@tonic-gate if (flag & FLG_UT_SHARP) { 25567c478bd9Sstevel@tonic-gate if (base == 16) { 25577c478bd9Sstevel@tonic-gate prefix = MSG_ORIG(MSG_STR_HEX); 25587c478bd9Sstevel@tonic-gate psize = 2; 25597c478bd9Sstevel@tonic-gate } else { 25607c478bd9Sstevel@tonic-gate prefix = MSG_ORIG(MSG_STR_ZERO); 25617c478bd9Sstevel@tonic-gate psize = 1; 25627c478bd9Sstevel@tonic-gate } 25637c478bd9Sstevel@tonic-gate } 25647c478bd9Sstevel@tonic-gate if ((base == 10) && (long)num < 0) { 25657c478bd9Sstevel@tonic-gate prefix = MSG_ORIG(MSG_STR_NEGATE); 25667c478bd9Sstevel@tonic-gate psize = MSG_STR_NEGATE_SIZE; 25677c478bd9Sstevel@tonic-gate num = (u_longlong_t)(-(longlong_t)num); 25687c478bd9Sstevel@tonic-gate } 25697c478bd9Sstevel@tonic-gate 25707c478bd9Sstevel@tonic-gate /* 25717c478bd9Sstevel@tonic-gate * Convert the numeric value into a local 25727c478bd9Sstevel@tonic-gate * string (stored in reverse order). 25737c478bd9Sstevel@tonic-gate */ 25747c478bd9Sstevel@tonic-gate _s = local; 25757c478bd9Sstevel@tonic-gate do { 25767c478bd9Sstevel@tonic-gate *_s++ = string[num % base]; 25777c478bd9Sstevel@tonic-gate num /= base; 25787c478bd9Sstevel@tonic-gate ssize++; 25797c478bd9Sstevel@tonic-gate } while (num); 25807c478bd9Sstevel@tonic-gate 25817c478bd9Sstevel@tonic-gate /* 25827c478bd9Sstevel@tonic-gate * Provide any precision or width padding. 25837c478bd9Sstevel@tonic-gate */ 25847c478bd9Sstevel@tonic-gate if (prec) { 25857c478bd9Sstevel@tonic-gate /* LINTED */ 25867c478bd9Sstevel@tonic-gate _n = (int)(prec - ssize); 25877c478bd9Sstevel@tonic-gate while (_n-- > 0) { 25887c478bd9Sstevel@tonic-gate *_s++ = '0'; 25897c478bd9Sstevel@tonic-gate ssize++; 25907c478bd9Sstevel@tonic-gate } 25917c478bd9Sstevel@tonic-gate } 25927c478bd9Sstevel@tonic-gate if (width && !(flag & FLG_UT_MINUS)) { 25937c478bd9Sstevel@tonic-gate /* LINTED */ 25947c478bd9Sstevel@tonic-gate _n = (int)(width - ssize - psize); 25957c478bd9Sstevel@tonic-gate while (_n-- > 0) { 25967c478bd9Sstevel@tonic-gate PUTC(' '); 25977c478bd9Sstevel@tonic-gate } 25987c478bd9Sstevel@tonic-gate } 25997c478bd9Sstevel@tonic-gate 26007c478bd9Sstevel@tonic-gate /* 26017c478bd9Sstevel@tonic-gate * Print any prefix and the numeric string 26027c478bd9Sstevel@tonic-gate */ 26037c478bd9Sstevel@tonic-gate while (*prefix) 26047c478bd9Sstevel@tonic-gate PUTC(*prefix++); 26057c478bd9Sstevel@tonic-gate do { 26067c478bd9Sstevel@tonic-gate PUTC(*--_s); 26077c478bd9Sstevel@tonic-gate } while (_s > local); 26087c478bd9Sstevel@tonic-gate 26097c478bd9Sstevel@tonic-gate /* 26107c478bd9Sstevel@tonic-gate * Provide any width padding. 26117c478bd9Sstevel@tonic-gate */ 26127c478bd9Sstevel@tonic-gate if (width && (flag & FLG_UT_MINUS)) { 26137c478bd9Sstevel@tonic-gate /* LINTED */ 26147c478bd9Sstevel@tonic-gate _n = (int)(width - ssize - psize); 26157c478bd9Sstevel@tonic-gate while (_n-- > 0) 26167c478bd9Sstevel@tonic-gate PUTC(' '); 26177c478bd9Sstevel@tonic-gate } 26187c478bd9Sstevel@tonic-gate } 26197c478bd9Sstevel@tonic-gate } 26207c478bd9Sstevel@tonic-gate } 2621*10a4fa49Srie 26227c478bd9Sstevel@tonic-gate PUTC('\0'); 26237c478bd9Sstevel@tonic-gate prf->pr_cur = bp; 26247c478bd9Sstevel@tonic-gate return (1); 26257c478bd9Sstevel@tonic-gate } 26267c478bd9Sstevel@tonic-gate 26277c478bd9Sstevel@tonic-gate static int 26287c478bd9Sstevel@tonic-gate doprintf(const char *format, va_list args, Prfbuf *prf) 26297c478bd9Sstevel@tonic-gate { 26307c478bd9Sstevel@tonic-gate char *ocur = prf->pr_cur; 26317c478bd9Sstevel@tonic-gate 26327c478bd9Sstevel@tonic-gate if (doprf(format, args, prf) == 0) 26337c478bd9Sstevel@tonic-gate return (0); 26347c478bd9Sstevel@tonic-gate /* LINTED */ 26357c478bd9Sstevel@tonic-gate return ((int)(prf->pr_cur - ocur)); 26367c478bd9Sstevel@tonic-gate } 26377c478bd9Sstevel@tonic-gate 26387c478bd9Sstevel@tonic-gate /* VARARGS2 */ 26397c478bd9Sstevel@tonic-gate int 26407c478bd9Sstevel@tonic-gate sprintf(char *buf, const char *format, ...) 26417c478bd9Sstevel@tonic-gate { 26427c478bd9Sstevel@tonic-gate va_list args; 26437c478bd9Sstevel@tonic-gate int len; 26447c478bd9Sstevel@tonic-gate Prfbuf prf; 26457c478bd9Sstevel@tonic-gate 26467c478bd9Sstevel@tonic-gate va_start(args, format); 26477c478bd9Sstevel@tonic-gate prf.pr_buf = prf.pr_cur = buf; 26487c478bd9Sstevel@tonic-gate prf.pr_len = 0; 26497c478bd9Sstevel@tonic-gate prf.pr_fd = -1; 26507c478bd9Sstevel@tonic-gate len = doprintf(format, args, &prf); 26517c478bd9Sstevel@tonic-gate va_end(args); 26527c478bd9Sstevel@tonic-gate 26537c478bd9Sstevel@tonic-gate /* 26547c478bd9Sstevel@tonic-gate * sprintf() return value excludes the terminating null byte. 26557c478bd9Sstevel@tonic-gate */ 26567c478bd9Sstevel@tonic-gate return (len - 1); 26577c478bd9Sstevel@tonic-gate } 26587c478bd9Sstevel@tonic-gate 26597c478bd9Sstevel@tonic-gate /* VARARGS3 */ 26607c478bd9Sstevel@tonic-gate int 26617c478bd9Sstevel@tonic-gate snprintf(char *buf, size_t n, const char *format, ...) 26627c478bd9Sstevel@tonic-gate { 26637c478bd9Sstevel@tonic-gate va_list args; 26647c478bd9Sstevel@tonic-gate int len; 26657c478bd9Sstevel@tonic-gate Prfbuf prf; 26667c478bd9Sstevel@tonic-gate 26677c478bd9Sstevel@tonic-gate va_start(args, format); 26687c478bd9Sstevel@tonic-gate prf.pr_buf = prf.pr_cur = buf; 26697c478bd9Sstevel@tonic-gate prf.pr_len = n; 26707c478bd9Sstevel@tonic-gate prf.pr_fd = -1; 26717c478bd9Sstevel@tonic-gate len = doprintf(format, args, &prf); 26727c478bd9Sstevel@tonic-gate va_end(args); 26737c478bd9Sstevel@tonic-gate 26747c478bd9Sstevel@tonic-gate return (len); 26757c478bd9Sstevel@tonic-gate } 26767c478bd9Sstevel@tonic-gate 26777c478bd9Sstevel@tonic-gate /* VARARGS2 */ 26787c478bd9Sstevel@tonic-gate int 26797c478bd9Sstevel@tonic-gate bufprint(Prfbuf *prf, const char *format, ...) 26807c478bd9Sstevel@tonic-gate { 26817c478bd9Sstevel@tonic-gate va_list args; 26827c478bd9Sstevel@tonic-gate int len; 26837c478bd9Sstevel@tonic-gate 26847c478bd9Sstevel@tonic-gate va_start(args, format); 26857c478bd9Sstevel@tonic-gate len = doprintf(format, args, prf); 26867c478bd9Sstevel@tonic-gate va_end(args); 26877c478bd9Sstevel@tonic-gate 26887c478bd9Sstevel@tonic-gate return (len); 26897c478bd9Sstevel@tonic-gate } 26907c478bd9Sstevel@tonic-gate 26917c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 26927c478bd9Sstevel@tonic-gate int 26937c478bd9Sstevel@tonic-gate printf(const char *format, ...) 26947c478bd9Sstevel@tonic-gate { 26957c478bd9Sstevel@tonic-gate va_list args; 26967c478bd9Sstevel@tonic-gate char buffer[ERRSIZE]; 26977c478bd9Sstevel@tonic-gate Prfbuf prf; 26987c478bd9Sstevel@tonic-gate 26997c478bd9Sstevel@tonic-gate va_start(args, format); 27007c478bd9Sstevel@tonic-gate prf.pr_buf = prf.pr_cur = buffer; 27017c478bd9Sstevel@tonic-gate prf.pr_len = ERRSIZE; 27027c478bd9Sstevel@tonic-gate prf.pr_fd = 1; 27037c478bd9Sstevel@tonic-gate (void) doprf(format, args, &prf); 27047c478bd9Sstevel@tonic-gate va_end(args); 27057c478bd9Sstevel@tonic-gate /* 27067c478bd9Sstevel@tonic-gate * Trim trailing '\0' form buffer 27077c478bd9Sstevel@tonic-gate */ 27087c478bd9Sstevel@tonic-gate prf.pr_cur--; 27097c478bd9Sstevel@tonic-gate return (dowrite(&prf)); 27107c478bd9Sstevel@tonic-gate } 27117c478bd9Sstevel@tonic-gate 27127c478bd9Sstevel@tonic-gate static char errbuf[ERRSIZE], *nextptr = errbuf, *prevptr = 0; 27137c478bd9Sstevel@tonic-gate 27145aefb655Srie /*PRINTFLIKE3*/ 27157c478bd9Sstevel@tonic-gate void 27165aefb655Srie eprintf(Lm_list *lml, Error error, const char *format, ...) 27177c478bd9Sstevel@tonic-gate { 27187c478bd9Sstevel@tonic-gate va_list args; 27197c478bd9Sstevel@tonic-gate int overflow = 0; 27207c478bd9Sstevel@tonic-gate static int lock = 0; 27217c478bd9Sstevel@tonic-gate Prfbuf prf; 27227c478bd9Sstevel@tonic-gate 27237c478bd9Sstevel@tonic-gate if (lock || (nextptr == (errbuf + ERRSIZE))) 27247c478bd9Sstevel@tonic-gate return; 27257c478bd9Sstevel@tonic-gate 27267c478bd9Sstevel@tonic-gate /* 27277c478bd9Sstevel@tonic-gate * Note: this lock is here to prevent the same thread from recursively 27287c478bd9Sstevel@tonic-gate * entering itself during a eprintf. ie: during eprintf malloc() fails 27297c478bd9Sstevel@tonic-gate * and we try and call eprintf ... and then malloc() fails .... 27307c478bd9Sstevel@tonic-gate */ 27317c478bd9Sstevel@tonic-gate lock = 1; 27327c478bd9Sstevel@tonic-gate 27337c478bd9Sstevel@tonic-gate /* 27347c478bd9Sstevel@tonic-gate * If we have completed startup initialization, all error messages 27357c478bd9Sstevel@tonic-gate * must be saved. These are reported through dlerror(). If we're 27367c478bd9Sstevel@tonic-gate * still in the initialization stage, output the error directly and 27377c478bd9Sstevel@tonic-gate * add a newline. 27387c478bd9Sstevel@tonic-gate */ 27397c478bd9Sstevel@tonic-gate va_start(args, format); 27407c478bd9Sstevel@tonic-gate 27417c478bd9Sstevel@tonic-gate prf.pr_buf = prf.pr_cur = nextptr; 27427c478bd9Sstevel@tonic-gate prf.pr_len = ERRSIZE - (nextptr - errbuf); 27437c478bd9Sstevel@tonic-gate 27447c478bd9Sstevel@tonic-gate if (!(rtld_flags & RT_FL_APPLIC)) 27457c478bd9Sstevel@tonic-gate prf.pr_fd = 2; 27467c478bd9Sstevel@tonic-gate else 27477c478bd9Sstevel@tonic-gate prf.pr_fd = -1; 27487c478bd9Sstevel@tonic-gate 27497c478bd9Sstevel@tonic-gate if (error > ERR_NONE) { 27507c478bd9Sstevel@tonic-gate if ((error == ERR_FATAL) && (rtld_flags2 & RT_FL2_FTL2WARN)) 27517c478bd9Sstevel@tonic-gate error = ERR_WARNING; 27527c478bd9Sstevel@tonic-gate if (error == ERR_WARNING) { 27537c478bd9Sstevel@tonic-gate if (err_strs[ERR_WARNING] == 0) 27547c478bd9Sstevel@tonic-gate err_strs[ERR_WARNING] = MSG_INTL(MSG_ERR_WARNING); 27557c478bd9Sstevel@tonic-gate } else if (error == ERR_FATAL) { 27567c478bd9Sstevel@tonic-gate if (err_strs[ERR_FATAL] == 0) 27577c478bd9Sstevel@tonic-gate err_strs[ERR_FATAL] = MSG_INTL(MSG_ERR_FATAL); 27587c478bd9Sstevel@tonic-gate } else if (error == ERR_ELF) { 27597c478bd9Sstevel@tonic-gate if (err_strs[ERR_ELF] == 0) 27607c478bd9Sstevel@tonic-gate err_strs[ERR_ELF] = MSG_INTL(MSG_ERR_ELF); 27617c478bd9Sstevel@tonic-gate } 276241072f3cSrie if (procname) { 276341072f3cSrie if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR1), 276441072f3cSrie rtldname, procname, err_strs[error]) == 0) 276541072f3cSrie overflow = 1; 27667c478bd9Sstevel@tonic-gate } else { 276741072f3cSrie if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2), 276841072f3cSrie rtldname, err_strs[error]) == 0) 276941072f3cSrie overflow = 1; 277041072f3cSrie } 277141072f3cSrie if (overflow == 0) { 27727c478bd9Sstevel@tonic-gate /* 27737c478bd9Sstevel@tonic-gate * Remove the terminating '\0'. 27747c478bd9Sstevel@tonic-gate */ 27757c478bd9Sstevel@tonic-gate prf.pr_cur--; 27767c478bd9Sstevel@tonic-gate } 27777c478bd9Sstevel@tonic-gate } 27787c478bd9Sstevel@tonic-gate 27797c478bd9Sstevel@tonic-gate if ((overflow == 0) && doprf(format, args, &prf) == 0) 27807c478bd9Sstevel@tonic-gate overflow = 1; 27817c478bd9Sstevel@tonic-gate 27827c478bd9Sstevel@tonic-gate /* 27837c478bd9Sstevel@tonic-gate * If this is an ELF error, it will have been generated by a support 27847c478bd9Sstevel@tonic-gate * object that has a dependency on libelf. ld.so.1 doesn't generate any 27857c478bd9Sstevel@tonic-gate * ELF error messages as it doesn't interact with libelf. Determine the 27867c478bd9Sstevel@tonic-gate * ELF error string. 27877c478bd9Sstevel@tonic-gate */ 27887c478bd9Sstevel@tonic-gate if ((overflow == 0) && (error == ERR_ELF)) { 27897c478bd9Sstevel@tonic-gate static int (*elfeno)() = 0; 27907c478bd9Sstevel@tonic-gate static const char *(*elfemg)(); 27917c478bd9Sstevel@tonic-gate const char *emsg; 27927c478bd9Sstevel@tonic-gate Rt_map *dlmp, *lmp = lml_rtld.lm_head; 27937c478bd9Sstevel@tonic-gate 27947c478bd9Sstevel@tonic-gate if (NEXT(lmp) && (elfeno == 0)) { 27957c478bd9Sstevel@tonic-gate if (((elfemg = (const char *(*)())dlsym_intn(RTLD_NEXT, 27967c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_SYM_ELFERRMSG), lmp, &dlmp)) == 0) || 27977c478bd9Sstevel@tonic-gate ((elfeno = (int (*)())dlsym_intn(RTLD_NEXT, 27987c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_SYM_ELFERRNO), lmp, &dlmp)) == 0)) 27997c478bd9Sstevel@tonic-gate elfeno = 0; 28007c478bd9Sstevel@tonic-gate } 28017c478bd9Sstevel@tonic-gate 28027c478bd9Sstevel@tonic-gate /* 28037c478bd9Sstevel@tonic-gate * Lookup the message; equivalent to elf_errmsg(elf_errno()). 28047c478bd9Sstevel@tonic-gate */ 28057c478bd9Sstevel@tonic-gate if (elfeno && ((emsg = (* elfemg)((* elfeno)())) != 0)) { 28067c478bd9Sstevel@tonic-gate prf.pr_cur--; 28077c478bd9Sstevel@tonic-gate if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2), 28087c478bd9Sstevel@tonic-gate emsg) == 0) 28097c478bd9Sstevel@tonic-gate overflow = 1; 28107c478bd9Sstevel@tonic-gate } 28117c478bd9Sstevel@tonic-gate } 28127c478bd9Sstevel@tonic-gate 28137c478bd9Sstevel@tonic-gate /* 28147c478bd9Sstevel@tonic-gate * Push out any message that's been built. Note, in the case of an 28157c478bd9Sstevel@tonic-gate * overflow condition, this message may be incomplete, in which case 28167c478bd9Sstevel@tonic-gate * make sure any partial string is null terminated. 28177c478bd9Sstevel@tonic-gate */ 28187c478bd9Sstevel@tonic-gate if (overflow) 28197c478bd9Sstevel@tonic-gate *(prf.pr_cur) = '\0'; 28207c478bd9Sstevel@tonic-gate if ((rtld_flags & (RT_FL_APPLIC | RT_FL_SILENCERR)) == 0) { 28217c478bd9Sstevel@tonic-gate *(prf.pr_cur - 1) = '\n'; 28227c478bd9Sstevel@tonic-gate (void) dowrite(&prf); 28237c478bd9Sstevel@tonic-gate } 28247c478bd9Sstevel@tonic-gate 28255aefb655Srie DBG_CALL(Dbg_util_str(lml, nextptr)); 28267c478bd9Sstevel@tonic-gate va_end(args); 28277c478bd9Sstevel@tonic-gate 28287c478bd9Sstevel@tonic-gate /* 28297c478bd9Sstevel@tonic-gate * Determine if there was insufficient space left in the buffer to 28307c478bd9Sstevel@tonic-gate * complete the message. If so, we'll have printed out as much as had 28317c478bd9Sstevel@tonic-gate * been processed if we're not yet executing the application. 28327c478bd9Sstevel@tonic-gate * Otherwise, there will be some debugging diagnostic indicating 28337c478bd9Sstevel@tonic-gate * as much of the error message as possible. Write out a final buffer 28347c478bd9Sstevel@tonic-gate * overflow diagnostic - unlocalized, so we don't chance more errors. 28357c478bd9Sstevel@tonic-gate */ 28367c478bd9Sstevel@tonic-gate if (overflow) { 28377c478bd9Sstevel@tonic-gate char *str = (char *)MSG_INTL(MSG_EMG_BUFOVRFLW); 28387c478bd9Sstevel@tonic-gate 28397c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SILENCERR) == 0) { 28407c478bd9Sstevel@tonic-gate lasterr = str; 28417c478bd9Sstevel@tonic-gate 28427c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_APPLIC) == 0) { 28437c478bd9Sstevel@tonic-gate (void) write(2, str, strlen(str)); 28447c478bd9Sstevel@tonic-gate (void) write(2, MSG_ORIG(MSG_STR_NL), 28457c478bd9Sstevel@tonic-gate MSG_STR_NL_SIZE); 28467c478bd9Sstevel@tonic-gate } 28477c478bd9Sstevel@tonic-gate } 28485aefb655Srie DBG_CALL(Dbg_util_str(lml, str)); 28497c478bd9Sstevel@tonic-gate 28507c478bd9Sstevel@tonic-gate lock = 0; 28517c478bd9Sstevel@tonic-gate nextptr = errbuf + ERRSIZE; 28527c478bd9Sstevel@tonic-gate return; 28537c478bd9Sstevel@tonic-gate } 28547c478bd9Sstevel@tonic-gate 28557c478bd9Sstevel@tonic-gate /* 28567c478bd9Sstevel@tonic-gate * If the application has started, then error messages are being saved 28577c478bd9Sstevel@tonic-gate * for retrieval by dlerror(), or possible flushing from rtldexit() in 28587c478bd9Sstevel@tonic-gate * the case of a fatal error. In this case, establish the next error 28597c478bd9Sstevel@tonic-gate * pointer. If we haven't started the application, the whole message 28607c478bd9Sstevel@tonic-gate * buffer can be reused. 28617c478bd9Sstevel@tonic-gate */ 28627c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SILENCERR) == 0) { 28637c478bd9Sstevel@tonic-gate lasterr = nextptr; 28647c478bd9Sstevel@tonic-gate 28657c478bd9Sstevel@tonic-gate /* 28667c478bd9Sstevel@tonic-gate * Note, should we encounter an error such as ENOMEM, there may 28677c478bd9Sstevel@tonic-gate * be a number of the same error messages (ie. an operation 28687c478bd9Sstevel@tonic-gate * fails with ENOMEM, and then the attempts to construct the 28697c478bd9Sstevel@tonic-gate * error message itself, which incurs additional ENOMEM errors). 28707c478bd9Sstevel@tonic-gate * Compare any previous error message with the one we've just 28717c478bd9Sstevel@tonic-gate * created to prevent any duplication clutter. 28727c478bd9Sstevel@tonic-gate */ 28737c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_APPLIC) && 28747c478bd9Sstevel@tonic-gate ((prevptr == 0) || (strcmp(prevptr, nextptr) != 0))) { 28757c478bd9Sstevel@tonic-gate prevptr = nextptr; 28767c478bd9Sstevel@tonic-gate nextptr = prf.pr_cur; 28777c478bd9Sstevel@tonic-gate *nextptr = '\0'; 28787c478bd9Sstevel@tonic-gate } 28797c478bd9Sstevel@tonic-gate } 28807c478bd9Sstevel@tonic-gate lock = 0; 28817c478bd9Sstevel@tonic-gate } 28827c478bd9Sstevel@tonic-gate 28837c478bd9Sstevel@tonic-gate 28847c478bd9Sstevel@tonic-gate #if DEBUG 28857c478bd9Sstevel@tonic-gate /* 28867c478bd9Sstevel@tonic-gate * Provide assfail() for ASSERT() statements, 28877c478bd9Sstevel@tonic-gate * see <sys/debug.h> for further details. 28887c478bd9Sstevel@tonic-gate */ 28897c478bd9Sstevel@tonic-gate int 28907c478bd9Sstevel@tonic-gate assfail(const char *a, const char *f, int l) 28917c478bd9Sstevel@tonic-gate { 28927c478bd9Sstevel@tonic-gate (void) printf("assertion failed: %s, file: %s, line: %d\n", a, f, l); 28937c478bd9Sstevel@tonic-gate (void) _lwp_kill(_lwp_self(), SIGABRT); 28947c478bd9Sstevel@tonic-gate return (0); 28957c478bd9Sstevel@tonic-gate } 28967c478bd9Sstevel@tonic-gate #endif 28977c478bd9Sstevel@tonic-gate 28987c478bd9Sstevel@tonic-gate /* 28997c478bd9Sstevel@tonic-gate * Exit. If we arrive here with a non zero status it's because of a fatal 29007c478bd9Sstevel@tonic-gate * error condition (most commonly a relocation error). If the application has 29017c478bd9Sstevel@tonic-gate * already had control, then the actual fatal error message will have been 29027c478bd9Sstevel@tonic-gate * recorded in the dlerror() message buffer. Print the message before really 29037c478bd9Sstevel@tonic-gate * exiting. 29047c478bd9Sstevel@tonic-gate */ 29057c478bd9Sstevel@tonic-gate void 29067c478bd9Sstevel@tonic-gate rtldexit(Lm_list * lml, int status) 29077c478bd9Sstevel@tonic-gate { 29087c478bd9Sstevel@tonic-gate if (status) { 29097c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_APPLIC) { 29107c478bd9Sstevel@tonic-gate /* 29117c478bd9Sstevel@tonic-gate * If the error buffer has been used, write out all 29127c478bd9Sstevel@tonic-gate * pending messages - lasterr is simply a pointer to 29137c478bd9Sstevel@tonic-gate * the last message in this buffer. However, if the 29147c478bd9Sstevel@tonic-gate * buffer couldn't be created at all, lasterr points 29157c478bd9Sstevel@tonic-gate * to a constant error message string. 29167c478bd9Sstevel@tonic-gate */ 29177c478bd9Sstevel@tonic-gate if (*errbuf) { 29187c478bd9Sstevel@tonic-gate char *errptr = errbuf; 29197c478bd9Sstevel@tonic-gate char *errend = errbuf + ERRSIZE; 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate while ((errptr < errend) && *errptr) { 29227c478bd9Sstevel@tonic-gate size_t size = strlen(errptr); 29237c478bd9Sstevel@tonic-gate (void) write(2, errptr, size); 29247c478bd9Sstevel@tonic-gate (void) write(2, MSG_ORIG(MSG_STR_NL), 29257c478bd9Sstevel@tonic-gate MSG_STR_NL_SIZE); 29267c478bd9Sstevel@tonic-gate errptr += (size + 1); 29277c478bd9Sstevel@tonic-gate } 29287c478bd9Sstevel@tonic-gate } 29297c478bd9Sstevel@tonic-gate if (lasterr && ((lasterr < errbuf) || 29307c478bd9Sstevel@tonic-gate (lasterr > (errbuf + ERRSIZE)))) { 29317c478bd9Sstevel@tonic-gate (void) write(2, lasterr, strlen(lasterr)); 29327c478bd9Sstevel@tonic-gate (void) write(2, MSG_ORIG(MSG_STR_NL), 29337c478bd9Sstevel@tonic-gate MSG_STR_NL_SIZE); 29347c478bd9Sstevel@tonic-gate } 29357c478bd9Sstevel@tonic-gate } 29367c478bd9Sstevel@tonic-gate leave(lml); 29377c478bd9Sstevel@tonic-gate (void) _lwp_kill(_lwp_self(), killsig); 29387c478bd9Sstevel@tonic-gate } 29397c478bd9Sstevel@tonic-gate _exit(status); 29407c478bd9Sstevel@tonic-gate } 29417c478bd9Sstevel@tonic-gate 29427c478bd9Sstevel@tonic-gate /* 29437c478bd9Sstevel@tonic-gate * Routines to co-ordinate the opening of /dev/zero and /proc. 29447c478bd9Sstevel@tonic-gate * dz_fd is exported for possible use by libld.so, and to insure it gets 29457c478bd9Sstevel@tonic-gate * closed on leaving ld.so.1. 29467c478bd9Sstevel@tonic-gate */ 29477c478bd9Sstevel@tonic-gate int dz_fd = FD_UNAVAIL; 29487c478bd9Sstevel@tonic-gate 29497c478bd9Sstevel@tonic-gate void 29507c478bd9Sstevel@tonic-gate dz_init(int fd) 29517c478bd9Sstevel@tonic-gate { 29527c478bd9Sstevel@tonic-gate dz_fd = fd; 29537c478bd9Sstevel@tonic-gate } 29547c478bd9Sstevel@tonic-gate 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate /* 29577c478bd9Sstevel@tonic-gate * mmap() a page from MAP_ANON 29587c478bd9Sstevel@tonic-gate * 29597c478bd9Sstevel@tonic-gate * Note: MAP_ANON is only on Solaris8++, we use this routine to 29607c478bd9Sstevel@tonic-gate * not only mmap(MAP_ANON) but to also probe if it is available 29617c478bd9Sstevel@tonic-gate * on the current OS. 29627c478bd9Sstevel@tonic-gate */ 29637c478bd9Sstevel@tonic-gate Am_ret 29645aefb655Srie anon_map(Lm_list *lml, caddr_t *addr, size_t len, int prot, int flags) 29657c478bd9Sstevel@tonic-gate { 29667c478bd9Sstevel@tonic-gate #if defined(MAP_ANON) 29677c478bd9Sstevel@tonic-gate static int noanon = 0; 29687c478bd9Sstevel@tonic-gate caddr_t va; 29697c478bd9Sstevel@tonic-gate 29707c478bd9Sstevel@tonic-gate if (noanon == 0) { 29717c478bd9Sstevel@tonic-gate if ((va = (caddr_t)mmap(*addr, len, prot, 29727c478bd9Sstevel@tonic-gate (flags | MAP_ANON), -1, 0)) != MAP_FAILED) { 29737c478bd9Sstevel@tonic-gate *addr = va; 29747c478bd9Sstevel@tonic-gate return (AM_OK); 29757c478bd9Sstevel@tonic-gate } 29767c478bd9Sstevel@tonic-gate 29777c478bd9Sstevel@tonic-gate if ((errno != EBADF) && (errno != EINVAL)) { 29787c478bd9Sstevel@tonic-gate int err = errno; 29795aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAPANON), 29807c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_DEVZERO), strerror(err)); 29817c478bd9Sstevel@tonic-gate return (AM_ERROR); 29827c478bd9Sstevel@tonic-gate } else 29837c478bd9Sstevel@tonic-gate noanon = 1; 29847c478bd9Sstevel@tonic-gate } 29857c478bd9Sstevel@tonic-gate #endif 29867c478bd9Sstevel@tonic-gate return (AM_NOSUP); 29877c478bd9Sstevel@tonic-gate } 29887c478bd9Sstevel@tonic-gate 29897c478bd9Sstevel@tonic-gate /* 29907c478bd9Sstevel@tonic-gate * Map anonymous memory from /dev/zero, or via MAP_ANON. 29917c478bd9Sstevel@tonic-gate * 29927c478bd9Sstevel@tonic-gate * (MAP_ANON only appears on Solaris 8, so we need fall-back 29937c478bd9Sstevel@tonic-gate * behavior for older systems.) 29947c478bd9Sstevel@tonic-gate */ 29957c478bd9Sstevel@tonic-gate caddr_t 29965aefb655Srie dz_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags) 29977c478bd9Sstevel@tonic-gate { 29987c478bd9Sstevel@tonic-gate caddr_t va; 29997c478bd9Sstevel@tonic-gate int err; 30007c478bd9Sstevel@tonic-gate Am_ret amret; 30017c478bd9Sstevel@tonic-gate 30025aefb655Srie amret = anon_map(lml, &addr, len, prot, flags); 30037c478bd9Sstevel@tonic-gate 30047c478bd9Sstevel@tonic-gate if (amret == AM_OK) 30057c478bd9Sstevel@tonic-gate return (addr); 30067c478bd9Sstevel@tonic-gate if (amret == AM_ERROR) 30077c478bd9Sstevel@tonic-gate return (MAP_FAILED); 30087c478bd9Sstevel@tonic-gate 30097c478bd9Sstevel@tonic-gate /* amret == AM_NOSUP -> fallback to a devzero mmaping */ 30107c478bd9Sstevel@tonic-gate 30117c478bd9Sstevel@tonic-gate if (dz_fd == FD_UNAVAIL) { 30127c478bd9Sstevel@tonic-gate if ((dz_fd = open(MSG_ORIG(MSG_PTH_DEVZERO), 30137c478bd9Sstevel@tonic-gate O_RDONLY)) == FD_UNAVAIL) { 30147c478bd9Sstevel@tonic-gate err = errno; 30155aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), 30167c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_DEVZERO), strerror(err)); 30177c478bd9Sstevel@tonic-gate return (MAP_FAILED); 30187c478bd9Sstevel@tonic-gate } 30197c478bd9Sstevel@tonic-gate } 30207c478bd9Sstevel@tonic-gate 30217c478bd9Sstevel@tonic-gate if ((va = mmap(addr, len, prot, flags, dz_fd, 0)) == MAP_FAILED) { 30227c478bd9Sstevel@tonic-gate err = errno; 30235aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAP), 30247c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_DEVZERO), strerror(err)); 30257c478bd9Sstevel@tonic-gate } 30267c478bd9Sstevel@tonic-gate return (va); 30277c478bd9Sstevel@tonic-gate } 30287c478bd9Sstevel@tonic-gate 30297c478bd9Sstevel@tonic-gate static int pr_fd = FD_UNAVAIL; 30307c478bd9Sstevel@tonic-gate 30317c478bd9Sstevel@tonic-gate int 30325aefb655Srie pr_open(Lm_list *lml) 30337c478bd9Sstevel@tonic-gate { 30347c478bd9Sstevel@tonic-gate char proc[16]; 30357c478bd9Sstevel@tonic-gate 30367c478bd9Sstevel@tonic-gate if (pr_fd == FD_UNAVAIL) { 30377c478bd9Sstevel@tonic-gate (void) snprintf(proc, 16, MSG_ORIG(MSG_FMT_PROC), 30387c478bd9Sstevel@tonic-gate (int)getpid()); 30397c478bd9Sstevel@tonic-gate if ((pr_fd = open(proc, O_RDONLY)) == FD_UNAVAIL) { 30407c478bd9Sstevel@tonic-gate int err = errno; 30417c478bd9Sstevel@tonic-gate 30425aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), proc, 30437c478bd9Sstevel@tonic-gate strerror(err)); 30447c478bd9Sstevel@tonic-gate } 30457c478bd9Sstevel@tonic-gate } 30467c478bd9Sstevel@tonic-gate return (pr_fd); 30477c478bd9Sstevel@tonic-gate } 30487c478bd9Sstevel@tonic-gate 30497c478bd9Sstevel@tonic-gate static int nu_fd = FD_UNAVAIL; 30507c478bd9Sstevel@tonic-gate 30517c478bd9Sstevel@tonic-gate caddr_t 30525aefb655Srie nu_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags) 30537c478bd9Sstevel@tonic-gate { 30547c478bd9Sstevel@tonic-gate caddr_t va; 30557c478bd9Sstevel@tonic-gate int err; 30567c478bd9Sstevel@tonic-gate 30577c478bd9Sstevel@tonic-gate if (nu_fd == FD_UNAVAIL) { 30587c478bd9Sstevel@tonic-gate if ((nu_fd = open(MSG_ORIG(MSG_PTH_DEVNULL), 30597c478bd9Sstevel@tonic-gate O_RDONLY)) == FD_UNAVAIL) { 30607c478bd9Sstevel@tonic-gate err = errno; 30615aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), 30627c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_DEVNULL), strerror(err)); 30637c478bd9Sstevel@tonic-gate return (MAP_FAILED); 30647c478bd9Sstevel@tonic-gate } 30657c478bd9Sstevel@tonic-gate } 30667c478bd9Sstevel@tonic-gate 30677c478bd9Sstevel@tonic-gate if ((va = (caddr_t)mmap(addr, len, prot, flags, nu_fd, 0)) == 30687c478bd9Sstevel@tonic-gate MAP_FAILED) { 30697c478bd9Sstevel@tonic-gate err = errno; 30705aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAP), 30717c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_DEVNULL), strerror(err)); 30727c478bd9Sstevel@tonic-gate } 30737c478bd9Sstevel@tonic-gate return (va); 30747c478bd9Sstevel@tonic-gate } 30757c478bd9Sstevel@tonic-gate 30767c478bd9Sstevel@tonic-gate /* 30777c478bd9Sstevel@tonic-gate * Generic entry point from user code - simply grabs a lock. 30787c478bd9Sstevel@tonic-gate */ 30797c478bd9Sstevel@tonic-gate int 30807c478bd9Sstevel@tonic-gate enter(void) 30817c478bd9Sstevel@tonic-gate { 30827c478bd9Sstevel@tonic-gate if (rt_bind_guard(THR_FLG_RTLD)) { 30837c478bd9Sstevel@tonic-gate (void) rt_mutex_lock(&rtldlock); 30847c478bd9Sstevel@tonic-gate return (1); 30857c478bd9Sstevel@tonic-gate } 30867c478bd9Sstevel@tonic-gate return (0); 30877c478bd9Sstevel@tonic-gate } 30887c478bd9Sstevel@tonic-gate 30897c478bd9Sstevel@tonic-gate /* 30907c478bd9Sstevel@tonic-gate * Generate diagnostics as to whether an object has been used. A symbolic 30917c478bd9Sstevel@tonic-gate * reference that gets bound to an object marks it as used. Dependencies that 30927c478bd9Sstevel@tonic-gate * are unused when RTLD_NOW is in effect should be removed from future builds 30937c478bd9Sstevel@tonic-gate * of an object. Dependencies that are unused without RTLD_NOW in effect are 30947c478bd9Sstevel@tonic-gate * candidates for lazy-loading. 30957c478bd9Sstevel@tonic-gate * Unreferenced objects identify objects that are defined as dependencies but 30967c478bd9Sstevel@tonic-gate * are unreferenced by the caller (they may however be referenced by other 30977c478bd9Sstevel@tonic-gate * objects within the process, and therefore don't qualify as completely unused. 30987c478bd9Sstevel@tonic-gate */ 30997c478bd9Sstevel@tonic-gate void 31007c478bd9Sstevel@tonic-gate unused(Lm_list *lml) 31017c478bd9Sstevel@tonic-gate { 31027c478bd9Sstevel@tonic-gate Rt_map *lmp; 31037c478bd9Sstevel@tonic-gate int nl = 0; 31047c478bd9Sstevel@tonic-gate Word tracing; 31057c478bd9Sstevel@tonic-gate 31067c478bd9Sstevel@tonic-gate /* 31077c478bd9Sstevel@tonic-gate * If we're not tracing unused references or dependencies, or debugging 31087c478bd9Sstevel@tonic-gate * there's nothing to do. 31097c478bd9Sstevel@tonic-gate */ 31107c478bd9Sstevel@tonic-gate tracing = lml->lm_flags & (LML_FLG_TRC_UNREF | LML_FLG_TRC_UNUSED); 31117c478bd9Sstevel@tonic-gate 31125aefb655Srie if ((tracing == 0) && (DBG_ENABLED == 0)) 31137c478bd9Sstevel@tonic-gate return; 31147c478bd9Sstevel@tonic-gate 31157c478bd9Sstevel@tonic-gate /* 31167c478bd9Sstevel@tonic-gate * Traverse the link-maps looking for unreferenced or unused 31177c478bd9Sstevel@tonic-gate * dependencies. Ignore the first object on a link-map list, as this 31187c478bd9Sstevel@tonic-gate * is effectively always used. 31197c478bd9Sstevel@tonic-gate */ 31207c478bd9Sstevel@tonic-gate for (lmp = (Rt_map *)NEXT(lml->lm_head); lmp; 31217c478bd9Sstevel@tonic-gate lmp = (Rt_map *)NEXT(lmp)) { 31227c478bd9Sstevel@tonic-gate /* 31237c478bd9Sstevel@tonic-gate * If tracing unreferenced objects, or under debugging, 31247c478bd9Sstevel@tonic-gate * determine whether any of this objects callers haven't 31257c478bd9Sstevel@tonic-gate * referenced it. 31267c478bd9Sstevel@tonic-gate */ 31275aefb655Srie if ((tracing & LML_FLG_TRC_UNREF) || DBG_ENABLED) { 31287c478bd9Sstevel@tonic-gate Bnd_desc ** bdpp; 31297c478bd9Sstevel@tonic-gate Aliste off; 31307c478bd9Sstevel@tonic-gate 31317c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(CALLERS(lmp), off, bdpp)) { 31327c478bd9Sstevel@tonic-gate Bnd_desc * bdp = *bdpp; 31337c478bd9Sstevel@tonic-gate Rt_map * clmp; 31347c478bd9Sstevel@tonic-gate 31357c478bd9Sstevel@tonic-gate if (bdp->b_flags & BND_REFER) 31367c478bd9Sstevel@tonic-gate continue; 31377c478bd9Sstevel@tonic-gate 31387c478bd9Sstevel@tonic-gate clmp = bdp->b_caller; 31397c478bd9Sstevel@tonic-gate if (FLAGS1(clmp) & FL1_RT_LDDSTUB) 31407c478bd9Sstevel@tonic-gate continue; 31417c478bd9Sstevel@tonic-gate 31427c478bd9Sstevel@tonic-gate if (nl++ == 0) { 31437c478bd9Sstevel@tonic-gate if (tracing & LML_FLG_TRC_UNREF) 31447c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_STR_NL)); 31457c478bd9Sstevel@tonic-gate else 31465aefb655Srie DBG_CALL(Dbg_util_nl(lml, 31475aefb655Srie DBG_NL_STD)); 31487c478bd9Sstevel@tonic-gate } 31497c478bd9Sstevel@tonic-gate 31507c478bd9Sstevel@tonic-gate if (tracing & LML_FLG_TRC_UNREF) 31517c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_UNREF_FMT), 31527c478bd9Sstevel@tonic-gate NAME(lmp), NAME(clmp)); 31537c478bd9Sstevel@tonic-gate else 31545aefb655Srie DBG_CALL(Dbg_unused_unref(lmp, NAME(clmp))); 31557c478bd9Sstevel@tonic-gate } 31567c478bd9Sstevel@tonic-gate } 31577c478bd9Sstevel@tonic-gate 31587c478bd9Sstevel@tonic-gate /* 31597c478bd9Sstevel@tonic-gate * If tracing unused objects simply display those objects that 31607c478bd9Sstevel@tonic-gate * haven't been referenced by anyone. 31617c478bd9Sstevel@tonic-gate */ 31627c478bd9Sstevel@tonic-gate if (FLAGS1(lmp) & FL1_RT_USED) 31637c478bd9Sstevel@tonic-gate continue; 31647c478bd9Sstevel@tonic-gate 31657c478bd9Sstevel@tonic-gate if (nl++ == 0) { 31667c478bd9Sstevel@tonic-gate if (tracing) 31677c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_STR_NL)); 31687c478bd9Sstevel@tonic-gate else 31695aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 31707c478bd9Sstevel@tonic-gate } 31717c478bd9Sstevel@tonic-gate if (CYCGROUP(lmp)) { 31727c478bd9Sstevel@tonic-gate if (tracing) 31737c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_UNCYC_FMT), 31747c478bd9Sstevel@tonic-gate NAME(lmp), CYCGROUP(lmp)); 31757c478bd9Sstevel@tonic-gate else 31765aefb655Srie DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0, 31777c478bd9Sstevel@tonic-gate CYCGROUP(lmp))); 31787c478bd9Sstevel@tonic-gate } else { 31797c478bd9Sstevel@tonic-gate if (tracing) 31807c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_UNUSED_FMT), 31817c478bd9Sstevel@tonic-gate NAME(lmp)); 31827c478bd9Sstevel@tonic-gate else 31835aefb655Srie DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0, 0)); 31847c478bd9Sstevel@tonic-gate } 31857c478bd9Sstevel@tonic-gate } 31867c478bd9Sstevel@tonic-gate 31875aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 31887c478bd9Sstevel@tonic-gate } 31897c478bd9Sstevel@tonic-gate 31907c478bd9Sstevel@tonic-gate /* 31917c478bd9Sstevel@tonic-gate * Initialization routine for the Fmap structure. If the fmap structure is 31927c478bd9Sstevel@tonic-gate * already in use, any mapping is released. The structure is then initialized 31937c478bd9Sstevel@tonic-gate * in preparation for further use. 31947c478bd9Sstevel@tonic-gate */ 31957c478bd9Sstevel@tonic-gate void 31967c478bd9Sstevel@tonic-gate fmap_setup() 31977c478bd9Sstevel@tonic-gate { 31987c478bd9Sstevel@tonic-gate #if defined(MAP_ALIGN) 31997c478bd9Sstevel@tonic-gate /* 32007c478bd9Sstevel@tonic-gate * If MAP_ALIGN is set, the fm_addr has been seeded with an alignment 32017c478bd9Sstevel@tonic-gate * value. Otherwise, if fm_addr is non-null it indicates a mapping that 32027c478bd9Sstevel@tonic-gate * should now be freed. 32037c478bd9Sstevel@tonic-gate */ 32047c478bd9Sstevel@tonic-gate if (fmap->fm_maddr && ((fmap->fm_mflags & MAP_ALIGN) == 0)) 32057c478bd9Sstevel@tonic-gate (void) munmap((caddr_t)fmap->fm_maddr, fmap->fm_msize); 32067c478bd9Sstevel@tonic-gate 32077c478bd9Sstevel@tonic-gate /* 32087c478bd9Sstevel@tonic-gate * Providing we haven't determined that this system doesn't support 32097c478bd9Sstevel@tonic-gate * MAP_ALIGN, initialize the mapping address with the default segment 32107c478bd9Sstevel@tonic-gate * alignment. 32117c478bd9Sstevel@tonic-gate */ 32127c478bd9Sstevel@tonic-gate if ((rtld_flags2 & RT_FL2_NOMALIGN) == 0) { 32137c478bd9Sstevel@tonic-gate fmap->fm_maddr = (char *)M_SEGM_ALIGN; 32147c478bd9Sstevel@tonic-gate fmap->fm_mflags = MAP_PRIVATE | MAP_ALIGN; 32157c478bd9Sstevel@tonic-gate } else { 32167c478bd9Sstevel@tonic-gate fmap->fm_maddr = 0; 32177c478bd9Sstevel@tonic-gate fmap->fm_mflags = MAP_PRIVATE; 32187c478bd9Sstevel@tonic-gate } 32197c478bd9Sstevel@tonic-gate #else 32207c478bd9Sstevel@tonic-gate if (fmap->fm_maddr) 32217c478bd9Sstevel@tonic-gate (void) munmap((caddr_t)fmap->fm_maddr, fmap->fm_msize); 3222fb1354edSrie 32237c478bd9Sstevel@tonic-gate fmap->fm_maddr = 0; 32247c478bd9Sstevel@tonic-gate fmap->fm_mflags = MAP_PRIVATE; 32257c478bd9Sstevel@tonic-gate #endif 32267c478bd9Sstevel@tonic-gate 32277c478bd9Sstevel@tonic-gate fmap->fm_msize = syspagsz; 32287c478bd9Sstevel@tonic-gate fmap->fm_hwptr = 0; 32297c478bd9Sstevel@tonic-gate } 32307c478bd9Sstevel@tonic-gate 32317c478bd9Sstevel@tonic-gate /* 32327c478bd9Sstevel@tonic-gate * Generic cleanup routine called prior to returning control to the user. 32337c478bd9Sstevel@tonic-gate * Insures that any ld.so.1 specific file descriptors or temporary mapping are 32347c478bd9Sstevel@tonic-gate * released, and any locks dropped. 32357c478bd9Sstevel@tonic-gate */ 32367c478bd9Sstevel@tonic-gate void 32377c478bd9Sstevel@tonic-gate leave(Lm_list * lml) 32387c478bd9Sstevel@tonic-gate { 32397c478bd9Sstevel@tonic-gate /* 32407c478bd9Sstevel@tonic-gate * Alert the debuggers that the link-maps are consistent. 32417c478bd9Sstevel@tonic-gate */ 32427c478bd9Sstevel@tonic-gate if (lml) 32437c478bd9Sstevel@tonic-gate rd_event(lml, RD_DLACTIVITY, RT_CONSISTENT); 32447c478bd9Sstevel@tonic-gate 32457c478bd9Sstevel@tonic-gate if (dz_fd != FD_UNAVAIL) { 32467c478bd9Sstevel@tonic-gate (void) close(dz_fd); 32477c478bd9Sstevel@tonic-gate dz_fd = FD_UNAVAIL; 32487c478bd9Sstevel@tonic-gate } 32497c478bd9Sstevel@tonic-gate 32507c478bd9Sstevel@tonic-gate if (pr_fd != FD_UNAVAIL) { 32517c478bd9Sstevel@tonic-gate (void) close(pr_fd); 32527c478bd9Sstevel@tonic-gate pr_fd = FD_UNAVAIL; 32537c478bd9Sstevel@tonic-gate } 32547c478bd9Sstevel@tonic-gate 32557c478bd9Sstevel@tonic-gate if (nu_fd != FD_UNAVAIL) { 32567c478bd9Sstevel@tonic-gate (void) close(nu_fd); 32577c478bd9Sstevel@tonic-gate nu_fd = FD_UNAVAIL; 32587c478bd9Sstevel@tonic-gate } 32597c478bd9Sstevel@tonic-gate 32607c478bd9Sstevel@tonic-gate fmap_setup(); 32617c478bd9Sstevel@tonic-gate 32627c478bd9Sstevel@tonic-gate /* 32637c478bd9Sstevel@tonic-gate * Reinitialize error message pointer, and any overflow indication. 32647c478bd9Sstevel@tonic-gate */ 32657c478bd9Sstevel@tonic-gate nextptr = errbuf; 32667c478bd9Sstevel@tonic-gate prevptr = 0; 32677c478bd9Sstevel@tonic-gate 32687c478bd9Sstevel@tonic-gate /* 32697c478bd9Sstevel@tonic-gate * Don't drop our lock if we are running on our link-map list as 32707c478bd9Sstevel@tonic-gate * there's little point in doing so since we are single-threaded. 32717c478bd9Sstevel@tonic-gate * 32727c478bd9Sstevel@tonic-gate * LML_FLG_HOLDLOCK is set for: 32737c478bd9Sstevel@tonic-gate * *) The ld.so.1's link-map list. 32747c478bd9Sstevel@tonic-gate * *) The auditor's link-map if the environment is 32757c478bd9Sstevel@tonic-gate * libc/libthread un-unified. 32767c478bd9Sstevel@tonic-gate */ 32777c478bd9Sstevel@tonic-gate if (lml && (lml->lm_flags & LML_FLG_HOLDLOCK)) 32787c478bd9Sstevel@tonic-gate return; 32797c478bd9Sstevel@tonic-gate 32807c478bd9Sstevel@tonic-gate if (rt_bind_clear(0) & THR_FLG_RTLD) { 32817c478bd9Sstevel@tonic-gate (void) rt_mutex_unlock(&rtldlock); 32827c478bd9Sstevel@tonic-gate (void) rt_bind_clear(THR_FLG_RTLD); 32837c478bd9Sstevel@tonic-gate } 32847c478bd9Sstevel@tonic-gate } 32857c478bd9Sstevel@tonic-gate 32867c478bd9Sstevel@tonic-gate int 32877c478bd9Sstevel@tonic-gate callable(Rt_map * clmp, Rt_map * dlmp, Grp_hdl * ghp) 32887c478bd9Sstevel@tonic-gate { 32897c478bd9Sstevel@tonic-gate Alist * calp, * dalp; 32907c478bd9Sstevel@tonic-gate Aliste cnt1, cnt2; 32917c478bd9Sstevel@tonic-gate Grp_hdl ** ghpp1, ** ghpp2; 32927c478bd9Sstevel@tonic-gate 32937c478bd9Sstevel@tonic-gate /* 32947c478bd9Sstevel@tonic-gate * An object can always find symbols within itself. 32957c478bd9Sstevel@tonic-gate */ 32967c478bd9Sstevel@tonic-gate if (clmp == dlmp) 32977c478bd9Sstevel@tonic-gate return (1); 32987c478bd9Sstevel@tonic-gate 32997c478bd9Sstevel@tonic-gate /* 33007c478bd9Sstevel@tonic-gate * Don't allow an object to bind to an object that is being deleted 33017c478bd9Sstevel@tonic-gate * unless the binder is also being deleted. 33027c478bd9Sstevel@tonic-gate */ 33037c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & FLG_RT_DELETE) && 33047c478bd9Sstevel@tonic-gate ((FLAGS(clmp) & FLG_RT_DELETE) == 0)) 33057c478bd9Sstevel@tonic-gate return (0); 33067c478bd9Sstevel@tonic-gate 33077c478bd9Sstevel@tonic-gate /* 33087c478bd9Sstevel@tonic-gate * An object with world access can always bind to an object with global 33097c478bd9Sstevel@tonic-gate * visibility. 33107c478bd9Sstevel@tonic-gate */ 33117c478bd9Sstevel@tonic-gate if ((MODE(clmp) & RTLD_WORLD) && (MODE(dlmp) & RTLD_GLOBAL)) 33127c478bd9Sstevel@tonic-gate return (1); 33137c478bd9Sstevel@tonic-gate 33147c478bd9Sstevel@tonic-gate /* 33157c478bd9Sstevel@tonic-gate * An object with local access can only bind to an object that is a 33167c478bd9Sstevel@tonic-gate * member of the same group. 33177c478bd9Sstevel@tonic-gate */ 33187c478bd9Sstevel@tonic-gate if (((MODE(clmp) & RTLD_GROUP) == 0) || 33197c478bd9Sstevel@tonic-gate ((calp = GROUPS(clmp)) == 0) || ((dalp = GROUPS(dlmp)) == 0)) 33207c478bd9Sstevel@tonic-gate return (0); 33217c478bd9Sstevel@tonic-gate 33227c478bd9Sstevel@tonic-gate /* 33237c478bd9Sstevel@tonic-gate * Traverse the list of groups the caller is a part of. 33247c478bd9Sstevel@tonic-gate */ 33257c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(calp, cnt1, ghpp1)) { 33267c478bd9Sstevel@tonic-gate /* 33277c478bd9Sstevel@tonic-gate * If we're testing for the ability of two objects to bind to 33287c478bd9Sstevel@tonic-gate * each other regardless of a specific group, ignore that group. 33297c478bd9Sstevel@tonic-gate */ 33307c478bd9Sstevel@tonic-gate if (ghp && (*ghpp1 == ghp)) 33317c478bd9Sstevel@tonic-gate continue; 33327c478bd9Sstevel@tonic-gate 33337c478bd9Sstevel@tonic-gate /* 33347c478bd9Sstevel@tonic-gate * Traverse the list of groups the destination is a part of. 33357c478bd9Sstevel@tonic-gate */ 33367c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(dalp, cnt2, ghpp2)) { 33377c478bd9Sstevel@tonic-gate if (*ghpp1 == *ghpp2) 33387c478bd9Sstevel@tonic-gate return (1); 33397c478bd9Sstevel@tonic-gate } 33407c478bd9Sstevel@tonic-gate } 33417c478bd9Sstevel@tonic-gate return (0); 33427c478bd9Sstevel@tonic-gate } 33437c478bd9Sstevel@tonic-gate 33447c478bd9Sstevel@tonic-gate /* 33457c478bd9Sstevel@tonic-gate * Initialize the environ symbol. Traditionally this is carried out by the crt 33467c478bd9Sstevel@tonic-gate * code prior to jumping to main. However, init sections get fired before this 33477c478bd9Sstevel@tonic-gate * variable is initialized, so ld.so.1 sets this directly from the AUX vector 33487c478bd9Sstevel@tonic-gate * information. In addition, a process may have multiple link-maps (ld.so.1's 33497c478bd9Sstevel@tonic-gate * debugging and preloading objects), and link auditing, and each may need an 33507c478bd9Sstevel@tonic-gate * environ variable set. 33517c478bd9Sstevel@tonic-gate * 33527c478bd9Sstevel@tonic-gate * This routine is called after a relocation() pass, and thus provides for: 33537c478bd9Sstevel@tonic-gate * 33547c478bd9Sstevel@tonic-gate * o setting environ on the main link-map after the initial application and 33557c478bd9Sstevel@tonic-gate * its dependencies have been established. Typically environ lives in the 33567c478bd9Sstevel@tonic-gate * application (provided by its crt), but in older applications it might 33577c478bd9Sstevel@tonic-gate * be in libc. Who knows what's expected of applications not built on 33587c478bd9Sstevel@tonic-gate * Solaris. 33597c478bd9Sstevel@tonic-gate * 33607c478bd9Sstevel@tonic-gate * o after loading a new shared object. We can add shared objects to various 33617c478bd9Sstevel@tonic-gate * link-maps, and any link-map dependencies requiring getopt() require 33627c478bd9Sstevel@tonic-gate * their own environ. In addition, lazy loading might bring in the 336341072f3cSrie * supplier of environ (libc used to be a lazy loading candidate) after 336441072f3cSrie * the link-map has been established and other objects are present. 33657c478bd9Sstevel@tonic-gate * 33667c478bd9Sstevel@tonic-gate * This routine handles all these scenarios, without adding unnecessary overhead 33677c478bd9Sstevel@tonic-gate * to ld.so.1. 33687c478bd9Sstevel@tonic-gate */ 33697c478bd9Sstevel@tonic-gate void 33707c478bd9Sstevel@tonic-gate set_environ(Lm_list *lml) 33717c478bd9Sstevel@tonic-gate { 33727c478bd9Sstevel@tonic-gate Rt_map * dlmp; 33737c478bd9Sstevel@tonic-gate Sym * sym; 33747c478bd9Sstevel@tonic-gate Slookup sl; 33757c478bd9Sstevel@tonic-gate uint_t binfo; 33767c478bd9Sstevel@tonic-gate 33777c478bd9Sstevel@tonic-gate sl.sl_name = MSG_ORIG(MSG_SYM_ENVIRON); 33787c478bd9Sstevel@tonic-gate sl.sl_cmap = lml->lm_head; 33797c478bd9Sstevel@tonic-gate sl.sl_imap = lml->lm_head; 33807c478bd9Sstevel@tonic-gate sl.sl_hash = 0; 33817c478bd9Sstevel@tonic-gate sl.sl_rsymndx = 0; 33827c478bd9Sstevel@tonic-gate sl.sl_flags = LKUP_WEAK; 33837c478bd9Sstevel@tonic-gate 33847c478bd9Sstevel@tonic-gate if (sym = LM_LOOKUP_SYM(lml->lm_head)(&sl, &dlmp, &binfo)) { 338541072f3cSrie lml->lm_environ = (char ***)sym->st_value; 33867c478bd9Sstevel@tonic-gate 33877c478bd9Sstevel@tonic-gate if (!(FLAGS(dlmp) & FLG_RT_FIXED)) 338841072f3cSrie lml->lm_environ = 338941072f3cSrie (char ***)((uintptr_t)lml->lm_environ + 339041072f3cSrie (uintptr_t)ADDR(dlmp)); 339141072f3cSrie *(lml->lm_environ) = (char **)environ; 33927c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_ENVIRON; 33937c478bd9Sstevel@tonic-gate } 33947c478bd9Sstevel@tonic-gate } 33957c478bd9Sstevel@tonic-gate 33967c478bd9Sstevel@tonic-gate /* 33977c478bd9Sstevel@tonic-gate * Determine whether we have a secure executable. Uid and gid information 33987c478bd9Sstevel@tonic-gate * can be passed to us via the aux vector, however if these values are -1 33997c478bd9Sstevel@tonic-gate * then use the appropriate system call to obtain them. 34007c478bd9Sstevel@tonic-gate * 34017c478bd9Sstevel@tonic-gate * o If the user is the root they can do anything 34027c478bd9Sstevel@tonic-gate * 34037c478bd9Sstevel@tonic-gate * o If the real and effective uid's don't match, or the real and 34047c478bd9Sstevel@tonic-gate * effective gid's don't match then this is determined to be a `secure' 34057c478bd9Sstevel@tonic-gate * application. 34067c478bd9Sstevel@tonic-gate * 34077c478bd9Sstevel@tonic-gate * This function is called prior to any dependency processing (see _setup.c). 34087c478bd9Sstevel@tonic-gate * Any secure setting will remain in effect for the life of the process. 34097c478bd9Sstevel@tonic-gate */ 34107c478bd9Sstevel@tonic-gate void 34117c478bd9Sstevel@tonic-gate security(uid_t uid, uid_t euid, gid_t gid, gid_t egid, int auxflags) 34127c478bd9Sstevel@tonic-gate { 34137c478bd9Sstevel@tonic-gate #ifdef AT_SUN_AUXFLAGS 34147c478bd9Sstevel@tonic-gate if (auxflags != -1) { 34157c478bd9Sstevel@tonic-gate if ((auxflags & AF_SUN_SETUGID) != 0) 34167c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_SECURE; 34177c478bd9Sstevel@tonic-gate return; 34187c478bd9Sstevel@tonic-gate } 34197c478bd9Sstevel@tonic-gate #endif 34207c478bd9Sstevel@tonic-gate if (uid == -1) 34217c478bd9Sstevel@tonic-gate uid = getuid(); 34227c478bd9Sstevel@tonic-gate if (uid) { 34237c478bd9Sstevel@tonic-gate if (euid == -1) 34247c478bd9Sstevel@tonic-gate euid = geteuid(); 34257c478bd9Sstevel@tonic-gate if (uid != euid) 34267c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_SECURE; 34277c478bd9Sstevel@tonic-gate else { 34287c478bd9Sstevel@tonic-gate if (gid == -1) 34297c478bd9Sstevel@tonic-gate gid = getgid(); 34307c478bd9Sstevel@tonic-gate if (egid == -1) 34317c478bd9Sstevel@tonic-gate egid = getegid(); 34327c478bd9Sstevel@tonic-gate if (gid != egid) 34337c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_SECURE; 34347c478bd9Sstevel@tonic-gate } 34357c478bd9Sstevel@tonic-gate } 34367c478bd9Sstevel@tonic-gate } 34377c478bd9Sstevel@tonic-gate 34387c478bd9Sstevel@tonic-gate /* 34397c478bd9Sstevel@tonic-gate * _REENTRANT code gets errno redefined to a function so provide for return 34407c478bd9Sstevel@tonic-gate * of the thread errno if applicable. This has no meaning in ld.so.1 which 34417c478bd9Sstevel@tonic-gate * is basically singled threaded. Provide the interface for our dependencies. 34427c478bd9Sstevel@tonic-gate */ 34437c478bd9Sstevel@tonic-gate #undef errno 34447c478bd9Sstevel@tonic-gate #pragma weak _private___errno = ___errno 34457c478bd9Sstevel@tonic-gate int * 34467c478bd9Sstevel@tonic-gate ___errno() 34477c478bd9Sstevel@tonic-gate { 34487c478bd9Sstevel@tonic-gate extern int errno; 34497c478bd9Sstevel@tonic-gate 34507c478bd9Sstevel@tonic-gate return (&errno); 34517c478bd9Sstevel@tonic-gate } 34527c478bd9Sstevel@tonic-gate 34537c478bd9Sstevel@tonic-gate /* 34547c478bd9Sstevel@tonic-gate * The interface with the c library which is supplied through libdl.so.1. 34557c478bd9Sstevel@tonic-gate * A non-null argument allows a function pointer array to be passed to us which 34567c478bd9Sstevel@tonic-gate * is used to re-initialize the linker libc table. 34577c478bd9Sstevel@tonic-gate */ 34587c478bd9Sstevel@tonic-gate void 34597c478bd9Sstevel@tonic-gate _ld_libc(void * ptr) 34607c478bd9Sstevel@tonic-gate { 34617c478bd9Sstevel@tonic-gate get_lcinterface(_caller(caller(), CL_EXECDEF), (Lc_interface *)ptr); 34627c478bd9Sstevel@tonic-gate } 34637c478bd9Sstevel@tonic-gate 34647c478bd9Sstevel@tonic-gate /* 34657c478bd9Sstevel@tonic-gate * Determine whether a symbol name should be demangled. 34667c478bd9Sstevel@tonic-gate */ 34677c478bd9Sstevel@tonic-gate const char * 34687c478bd9Sstevel@tonic-gate demangle(const char *name) 34697c478bd9Sstevel@tonic-gate { 34707c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_DEMANGLE) 34715aefb655Srie return (conv_demangle_name(name)); 34727c478bd9Sstevel@tonic-gate else 34737c478bd9Sstevel@tonic-gate return (name); 34747c478bd9Sstevel@tonic-gate } 3475