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 /* 2320272c2eSAli Bahrami * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267257d1b4Sraf 277257d1b4Sraf /* 287257d1b4Sraf * Copyright (c) 1988 AT&T 297257d1b4Sraf * All Rights Reserved 307257d1b4Sraf */ 317257d1b4Sraf 327c478bd9Sstevel@tonic-gate /* 337c478bd9Sstevel@tonic-gate * Utility routines for run-time linker. some are duplicated here from libc 347c478bd9Sstevel@tonic-gate * (with different names) to avoid name space collisions. 357c478bd9Sstevel@tonic-gate */ 36*08278a5eSRod Evans #include <sys/systeminfo.h> 377c478bd9Sstevel@tonic-gate #include <stdio.h> 382017c965SRod Evans #include <sys/time.h> 397c478bd9Sstevel@tonic-gate #include <sys/types.h> 407c478bd9Sstevel@tonic-gate #include <sys/mman.h> 417c478bd9Sstevel@tonic-gate #include <sys/lwp.h> 427c478bd9Sstevel@tonic-gate #include <sys/debug.h> 437c478bd9Sstevel@tonic-gate #include <stdarg.h> 447c478bd9Sstevel@tonic-gate #include <fcntl.h> 457c478bd9Sstevel@tonic-gate #include <string.h> 467c478bd9Sstevel@tonic-gate #include <dlfcn.h> 477c478bd9Sstevel@tonic-gate #include <unistd.h> 487c478bd9Sstevel@tonic-gate #include <stdlib.h> 497c478bd9Sstevel@tonic-gate #include <sys/auxv.h> 5056deab07SRod Evans #include <limits.h> 515aefb655Srie #include <debug.h> 525aefb655Srie #include <conv.h> 537c478bd9Sstevel@tonic-gate #include "_rtld.h" 547c478bd9Sstevel@tonic-gate #include "_audit.h" 5510a4fa49Srie #include "_elf.h" 567c478bd9Sstevel@tonic-gate #include "msg.h" 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate static int ld_flags_env(const char *, Word *, Word *, uint_t, int); 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate /* 617c478bd9Sstevel@tonic-gate * Null function used as place where a debugger can set a breakpoint. 627c478bd9Sstevel@tonic-gate */ 637c478bd9Sstevel@tonic-gate void 645aefb655Srie rtld_db_dlactivity(Lm_list *lml) 657c478bd9Sstevel@tonic-gate { 665aefb655Srie DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent, 675aefb655Srie r_debug.rtd_rdebug.r_state)); 687c478bd9Sstevel@tonic-gate } 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate /* 717c478bd9Sstevel@tonic-gate * Null function used as place where debugger can set a pre .init 727c478bd9Sstevel@tonic-gate * processing breakpoint. 737c478bd9Sstevel@tonic-gate */ 747c478bd9Sstevel@tonic-gate void 755aefb655Srie rtld_db_preinit(Lm_list *lml) 767c478bd9Sstevel@tonic-gate { 775aefb655Srie DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent, 785aefb655Srie r_debug.rtd_rdebug.r_state)); 797c478bd9Sstevel@tonic-gate } 807c478bd9Sstevel@tonic-gate 817c478bd9Sstevel@tonic-gate /* 827c478bd9Sstevel@tonic-gate * Null function used as place where debugger can set a post .init 837c478bd9Sstevel@tonic-gate * processing breakpoint. 847c478bd9Sstevel@tonic-gate */ 857c478bd9Sstevel@tonic-gate void 865aefb655Srie rtld_db_postinit(Lm_list *lml) 877c478bd9Sstevel@tonic-gate { 885aefb655Srie DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent, 895aefb655Srie r_debug.rtd_rdebug.r_state)); 907c478bd9Sstevel@tonic-gate } 917c478bd9Sstevel@tonic-gate 927c478bd9Sstevel@tonic-gate /* 937c478bd9Sstevel@tonic-gate * Debugger Event Notification 947c478bd9Sstevel@tonic-gate * 957c478bd9Sstevel@tonic-gate * This function centralizes all debugger event notification (ala rtld_db). 967c478bd9Sstevel@tonic-gate * 977c478bd9Sstevel@tonic-gate * There's a simple intent, focused on insuring the primary link-map control 987c478bd9Sstevel@tonic-gate * list (or each link-map list) is consistent, and the indication that objects 997c478bd9Sstevel@tonic-gate * have been added or deleted from this list. Although an RD_ADD and RD_DELETE 1007c478bd9Sstevel@tonic-gate * event are posted for each of these, most debuggers don't care, as their 1017c478bd9Sstevel@tonic-gate * view is that these events simply convey an "inconsistent" state. 1027c478bd9Sstevel@tonic-gate * 1037c478bd9Sstevel@tonic-gate * We also don't want to trigger multiple RD_ADD/RD_DELETE events any time we 1047c478bd9Sstevel@tonic-gate * enter ld.so.1. 1057c478bd9Sstevel@tonic-gate * 1067c478bd9Sstevel@tonic-gate * With auditors, we may be in the process of relocating a collection of 1077c478bd9Sstevel@tonic-gate * objects, and will leave() ld.so.1 to call the auditor. At this point we 1087c478bd9Sstevel@tonic-gate * must indicate an RD_CONSISTENT event, but librtld_db will not report an 1097c478bd9Sstevel@tonic-gate * object to the debuggers until relocation processing has been completed on it. 1107c478bd9Sstevel@tonic-gate * To allow for the collection of these objects that are pending relocation, an 1117c478bd9Sstevel@tonic-gate * RD_ADD event is set after completing a series of relocations on the primary 1127c478bd9Sstevel@tonic-gate * link-map control list. 1137c478bd9Sstevel@tonic-gate * 1147c478bd9Sstevel@tonic-gate * Set an RD_ADD/RD_DELETE event and indicate that an RD_CONSISTENT event is 1157c478bd9Sstevel@tonic-gate * required later (LML_FLG_DBNOTIF): 1167c478bd9Sstevel@tonic-gate * 1177c478bd9Sstevel@tonic-gate * i the first time we add or delete an object to the primary link-map 1187c478bd9Sstevel@tonic-gate * control list. 1197c478bd9Sstevel@tonic-gate * ii the first time we move a secondary link-map control list to the primary 1207c478bd9Sstevel@tonic-gate * link-map control list (effectively, this is like adding a group of 1217c478bd9Sstevel@tonic-gate * objects to the primary link-map control list). 1227c478bd9Sstevel@tonic-gate * 1237c478bd9Sstevel@tonic-gate * Set an RD_CONSISTENT event when it is required (LML_FLG_DBNOTIF is set) and 1247c478bd9Sstevel@tonic-gate * 1257c478bd9Sstevel@tonic-gate * i each time we leave the runtime linker. 1267c478bd9Sstevel@tonic-gate */ 1277c478bd9Sstevel@tonic-gate void 1287c478bd9Sstevel@tonic-gate rd_event(Lm_list *lml, rd_event_e event, r_state_e state) 1297c478bd9Sstevel@tonic-gate { 13010a4fa49Srie void (*fptr)(Lm_list *); 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate switch (event) { 1337c478bd9Sstevel@tonic-gate case RD_PREINIT: 1347c478bd9Sstevel@tonic-gate fptr = rtld_db_preinit; 1357c478bd9Sstevel@tonic-gate break; 1367c478bd9Sstevel@tonic-gate case RD_POSTINIT: 1377c478bd9Sstevel@tonic-gate fptr = rtld_db_postinit; 1387c478bd9Sstevel@tonic-gate break; 1397c478bd9Sstevel@tonic-gate case RD_DLACTIVITY: 1407c478bd9Sstevel@tonic-gate switch (state) { 1417c478bd9Sstevel@tonic-gate case RT_CONSISTENT: 1427c478bd9Sstevel@tonic-gate lml->lm_flags &= ~LML_FLG_DBNOTIF; 1437c478bd9Sstevel@tonic-gate 1447c478bd9Sstevel@tonic-gate /* 1457c478bd9Sstevel@tonic-gate * Do we need to send a notification? 1467c478bd9Sstevel@tonic-gate */ 1477c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_DBNOTIF) == 0) 1487c478bd9Sstevel@tonic-gate return; 1497c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_DBNOTIF; 1507c478bd9Sstevel@tonic-gate break; 1517c478bd9Sstevel@tonic-gate case RT_ADD: 1527c478bd9Sstevel@tonic-gate case RT_DELETE: 1537c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_DBNOTIF; 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate /* 1567c478bd9Sstevel@tonic-gate * If we are already in an inconsistent state, no 1577c478bd9Sstevel@tonic-gate * notification is required. 1587c478bd9Sstevel@tonic-gate */ 1597c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_DBNOTIF) 1607c478bd9Sstevel@tonic-gate return; 1617c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_DBNOTIF; 1627c478bd9Sstevel@tonic-gate break; 1637c478bd9Sstevel@tonic-gate }; 1647c478bd9Sstevel@tonic-gate fptr = rtld_db_dlactivity; 1657c478bd9Sstevel@tonic-gate break; 1667c478bd9Sstevel@tonic-gate default: 1677c478bd9Sstevel@tonic-gate /* 1687c478bd9Sstevel@tonic-gate * RD_NONE - do nothing 1697c478bd9Sstevel@tonic-gate */ 1707c478bd9Sstevel@tonic-gate break; 1717c478bd9Sstevel@tonic-gate }; 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate /* 1747c478bd9Sstevel@tonic-gate * Set event state and call 'notification' function. 1757c478bd9Sstevel@tonic-gate * 1767c478bd9Sstevel@tonic-gate * The debugging clients have previously been told about these 1777c478bd9Sstevel@tonic-gate * notification functions and have set breakpoints on them if they 1787c478bd9Sstevel@tonic-gate * are interested in the notification. 1797c478bd9Sstevel@tonic-gate */ 1807c478bd9Sstevel@tonic-gate r_debug.rtd_rdebug.r_state = state; 1817c478bd9Sstevel@tonic-gate r_debug.rtd_rdebug.r_rdevent = event; 1825aefb655Srie fptr(lml); 1837c478bd9Sstevel@tonic-gate r_debug.rtd_rdebug.r_rdevent = RD_NONE; 1847c478bd9Sstevel@tonic-gate } 1857c478bd9Sstevel@tonic-gate 18602ca3e02Srie #if defined(__sparc) || defined(__x86) 1877c478bd9Sstevel@tonic-gate /* 1887c478bd9Sstevel@tonic-gate * Stack Cleanup. 1897c478bd9Sstevel@tonic-gate * 1907c478bd9Sstevel@tonic-gate * This function is invoked to 'remove' arguments that were passed in on the 1917c478bd9Sstevel@tonic-gate * stack. This is most likely if ld.so.1 was invoked directly. In that case 1927c478bd9Sstevel@tonic-gate * we want to remove ld.so.1 as well as it's arguments from the argv[] array. 1937c478bd9Sstevel@tonic-gate * Which means we then need to slide everything above it on the stack down 1947c478bd9Sstevel@tonic-gate * accordingly. 1957c478bd9Sstevel@tonic-gate * 19602ca3e02Srie * While the stack layout is platform specific - it just so happens that __x86, 19702ca3e02Srie * and __sparc platforms share the following initial stack layout. 1987c478bd9Sstevel@tonic-gate * 1997c478bd9Sstevel@tonic-gate * !_______________________! high addresses 2007c478bd9Sstevel@tonic-gate * ! ! 2017c478bd9Sstevel@tonic-gate * ! Information ! 2027c478bd9Sstevel@tonic-gate * ! Block ! 2037c478bd9Sstevel@tonic-gate * ! (size varies) ! 2047c478bd9Sstevel@tonic-gate * !_______________________! 2057c478bd9Sstevel@tonic-gate * ! 0 word ! 2067c478bd9Sstevel@tonic-gate * !_______________________! 2077c478bd9Sstevel@tonic-gate * ! Auxiliary ! 2087c478bd9Sstevel@tonic-gate * ! vector ! 2097c478bd9Sstevel@tonic-gate * ! 2 word entries ! 2107c478bd9Sstevel@tonic-gate * ! ! 2117c478bd9Sstevel@tonic-gate * !_______________________! 2127c478bd9Sstevel@tonic-gate * ! 0 word ! 2137c478bd9Sstevel@tonic-gate * !_______________________! 2147c478bd9Sstevel@tonic-gate * ! Environment ! 2157c478bd9Sstevel@tonic-gate * ! pointers ! 2167c478bd9Sstevel@tonic-gate * ! ... ! 2177c478bd9Sstevel@tonic-gate * ! (one word each) ! 2187c478bd9Sstevel@tonic-gate * !_______________________! 2197c478bd9Sstevel@tonic-gate * ! 0 word ! 2207c478bd9Sstevel@tonic-gate * !_______________________! 2217c478bd9Sstevel@tonic-gate * ! Argument ! low addresses 2227c478bd9Sstevel@tonic-gate * ! pointers ! 2237c478bd9Sstevel@tonic-gate * ! Argc words ! 2247c478bd9Sstevel@tonic-gate * !_______________________! 2257c478bd9Sstevel@tonic-gate * ! ! 2267c478bd9Sstevel@tonic-gate * ! Argc ! 2277c478bd9Sstevel@tonic-gate * !_______________________! 2287c478bd9Sstevel@tonic-gate * ! ... ! 2297c478bd9Sstevel@tonic-gate * 2307c478bd9Sstevel@tonic-gate */ 2317c478bd9Sstevel@tonic-gate static void 23241072f3cSrie stack_cleanup(char **argv, char ***envp, auxv_t **auxv, int rmcnt) 2337c478bd9Sstevel@tonic-gate { 23441072f3cSrie int ndx; 2357c478bd9Sstevel@tonic-gate long *argc; 23641072f3cSrie char **oargv, **nargv; 23741072f3cSrie char **oenvp, **nenvp; 23841072f3cSrie auxv_t *oauxv, *nauxv; 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate /* 24141072f3cSrie * Slide ARGV[] and update argc. The argv pointer remains the same, 24241072f3cSrie * however slide the applications arguments over the arguments to 24341072f3cSrie * ld.so.1. 2447c478bd9Sstevel@tonic-gate */ 24541072f3cSrie nargv = &argv[0]; 24641072f3cSrie oargv = &argv[rmcnt]; 24741072f3cSrie 24841072f3cSrie for (ndx = 0; oargv[ndx]; ndx++) 24941072f3cSrie nargv[ndx] = oargv[ndx]; 25041072f3cSrie nargv[ndx] = oargv[ndx]; 25141072f3cSrie 25241072f3cSrie argc = (long *)((uintptr_t)argv - sizeof (long *)); 2537c478bd9Sstevel@tonic-gate *argc -= rmcnt; 2547c478bd9Sstevel@tonic-gate 2557c478bd9Sstevel@tonic-gate /* 25641072f3cSrie * Slide ENVP[], and update the environment array pointer. 2577c478bd9Sstevel@tonic-gate */ 25841072f3cSrie ndx++; 25941072f3cSrie nenvp = &nargv[ndx]; 26041072f3cSrie oenvp = &oargv[ndx]; 26141072f3cSrie *envp = nenvp; 26241072f3cSrie 26341072f3cSrie for (ndx = 0; oenvp[ndx]; ndx++) 26441072f3cSrie nenvp[ndx] = oenvp[ndx]; 26541072f3cSrie nenvp[ndx] = oenvp[ndx]; 2667c478bd9Sstevel@tonic-gate 2677c478bd9Sstevel@tonic-gate /* 26841072f3cSrie * Slide AUXV[], and update the aux vector pointer. 2697c478bd9Sstevel@tonic-gate */ 27041072f3cSrie ndx++; 27141072f3cSrie nauxv = (auxv_t *)&nenvp[ndx]; 27241072f3cSrie oauxv = (auxv_t *)&oenvp[ndx]; 27341072f3cSrie *auxv = nauxv; 27441072f3cSrie 27541072f3cSrie for (ndx = 0; (oauxv[ndx].a_type != AT_NULL); ndx++) 27641072f3cSrie nauxv[ndx] = oauxv[ndx]; 27741072f3cSrie nauxv[ndx] = oauxv[ndx]; 2787c478bd9Sstevel@tonic-gate } 2797c478bd9Sstevel@tonic-gate #else 2807c478bd9Sstevel@tonic-gate /* 2817c478bd9Sstevel@tonic-gate * Verify that the above routine is appropriate for any new platforms. 2827c478bd9Sstevel@tonic-gate */ 2837c478bd9Sstevel@tonic-gate #error unsupported architecture! 2847c478bd9Sstevel@tonic-gate #endif 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate /* 28741072f3cSrie * The only command line argument recognized is -e, followed by a runtime 28841072f3cSrie * linker environment variable. 2897c478bd9Sstevel@tonic-gate */ 2907c478bd9Sstevel@tonic-gate int 29141072f3cSrie rtld_getopt(char **argv, char ***envp, auxv_t **auxv, Word *lmflags, 29241072f3cSrie Word *lmtflags, int aout) 2937c478bd9Sstevel@tonic-gate { 29441072f3cSrie int ndx; 2957c478bd9Sstevel@tonic-gate 29641072f3cSrie for (ndx = 1; argv[ndx]; ndx++) { 2977c478bd9Sstevel@tonic-gate char *str; 2987c478bd9Sstevel@tonic-gate 29941072f3cSrie if (argv[ndx][0] != '-') 3007c478bd9Sstevel@tonic-gate break; 3017c478bd9Sstevel@tonic-gate 30241072f3cSrie if (argv[ndx][1] == '\0') { 30341072f3cSrie ndx++; 3047c478bd9Sstevel@tonic-gate break; 3057c478bd9Sstevel@tonic-gate } 3067c478bd9Sstevel@tonic-gate 30741072f3cSrie if (argv[ndx][1] != 'e') 30841072f3cSrie return (1); 3097c478bd9Sstevel@tonic-gate 31041072f3cSrie if (argv[ndx][2] == '\0') { 31141072f3cSrie ndx++; 31241072f3cSrie if (argv[ndx] == NULL) 31341072f3cSrie return (1); 31441072f3cSrie str = argv[ndx]; 3157c478bd9Sstevel@tonic-gate } else 31641072f3cSrie str = &argv[ndx][2]; 3177c478bd9Sstevel@tonic-gate 31841072f3cSrie /* 31941072f3cSrie * If the environment variable starts with LD_, strip the LD_. 32041072f3cSrie * Otherwise, take things as is. 32141072f3cSrie */ 32241072f3cSrie if ((str[0] == 'L') && (str[1] == 'D') && (str[2] == '_') && 32341072f3cSrie (str[3] != '\0')) 32441072f3cSrie str += 3; 3257c478bd9Sstevel@tonic-gate if (ld_flags_env(str, lmflags, lmtflags, 0, aout) == 1) 3267c478bd9Sstevel@tonic-gate return (1); 3277c478bd9Sstevel@tonic-gate } 3287c478bd9Sstevel@tonic-gate 32941072f3cSrie /* 33041072f3cSrie * Make sure an object file has been specified. 33141072f3cSrie */ 33243d7826aSRod Evans if (argv[ndx] == NULL) 3337c478bd9Sstevel@tonic-gate return (1); 3347c478bd9Sstevel@tonic-gate 3357c478bd9Sstevel@tonic-gate /* 3367c478bd9Sstevel@tonic-gate * Having gotten the arguments, clean ourselves off of the stack. 3377c478bd9Sstevel@tonic-gate */ 33841072f3cSrie stack_cleanup(argv, envp, auxv, ndx); 3397c478bd9Sstevel@tonic-gate return (0); 3407c478bd9Sstevel@tonic-gate } 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate /* 3439aa23310Srie * Compare function for PathNode AVL tree. 3447c478bd9Sstevel@tonic-gate */ 3457c478bd9Sstevel@tonic-gate static int 3469aa23310Srie pnavl_compare(const void *n1, const void *n2) 3477c478bd9Sstevel@tonic-gate { 3487c478bd9Sstevel@tonic-gate uint_t hash1, hash2; 3497c478bd9Sstevel@tonic-gate const char *st1, *st2; 3507c478bd9Sstevel@tonic-gate int rc; 3517c478bd9Sstevel@tonic-gate 3529aa23310Srie hash1 = ((PathNode *)n1)->pn_hash; 3539aa23310Srie hash2 = ((PathNode *)n2)->pn_hash; 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate if (hash1 > hash2) 3567c478bd9Sstevel@tonic-gate return (1); 3577c478bd9Sstevel@tonic-gate if (hash1 < hash2) 3587c478bd9Sstevel@tonic-gate return (-1); 3597c478bd9Sstevel@tonic-gate 3609aa23310Srie st1 = ((PathNode *)n1)->pn_name; 3619aa23310Srie st2 = ((PathNode *)n2)->pn_name; 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate rc = strcmp(st1, st2); 3647c478bd9Sstevel@tonic-gate if (rc > 0) 3657c478bd9Sstevel@tonic-gate return (1); 3667c478bd9Sstevel@tonic-gate if (rc < 0) 3677c478bd9Sstevel@tonic-gate return (-1); 3687c478bd9Sstevel@tonic-gate return (0); 3697c478bd9Sstevel@tonic-gate } 3707c478bd9Sstevel@tonic-gate 3713dbfc803SRod Evans /* 3723dbfc803SRod Evans * Create an AVL tree. 3733dbfc803SRod Evans */ 3743dbfc803SRod Evans static avl_tree_t * 3753dbfc803SRod Evans pnavl_create(size_t size) 3763dbfc803SRod Evans { 3773dbfc803SRod Evans avl_tree_t *avlt; 3783dbfc803SRod Evans 3793dbfc803SRod Evans if ((avlt = malloc(sizeof (avl_tree_t))) == NULL) 3803dbfc803SRod Evans return (NULL); 3813dbfc803SRod Evans avl_create(avlt, pnavl_compare, size, SGSOFFSETOF(PathNode, pn_avl)); 3823dbfc803SRod Evans return (avlt); 3833dbfc803SRod Evans } 3843dbfc803SRod Evans 385*08278a5eSRod Evans /* 386*08278a5eSRod Evans * Determine whether a PathNode is recorded. 387*08278a5eSRod Evans */ 388*08278a5eSRod Evans int 389*08278a5eSRod Evans pnavl_recorded(avl_tree_t **pnavl, const char *name, uint_t hash, 390*08278a5eSRod Evans avl_index_t *where) 391*08278a5eSRod Evans { 392*08278a5eSRod Evans PathNode pn; 393*08278a5eSRod Evans 394*08278a5eSRod Evans /* 395*08278a5eSRod Evans * Create the avl tree if required. 396*08278a5eSRod Evans */ 397*08278a5eSRod Evans if ((*pnavl == NULL) && 398*08278a5eSRod Evans ((*pnavl = pnavl_create(sizeof (PathNode))) == NULL)) 399*08278a5eSRod Evans return (0); 400*08278a5eSRod Evans 401*08278a5eSRod Evans pn.pn_name = name; 402*08278a5eSRod Evans if ((pn.pn_hash = hash) == 0) 403*08278a5eSRod Evans pn.pn_hash = sgs_str_hash(name); 404*08278a5eSRod Evans 405*08278a5eSRod Evans if (avl_find(*pnavl, &pn, where) == NULL) 406*08278a5eSRod Evans return (0); 407*08278a5eSRod Evans 408*08278a5eSRod Evans return (1); 409*08278a5eSRod Evans } 410*08278a5eSRod Evans 4117c478bd9Sstevel@tonic-gate /* 4129aa23310Srie * Determine if a pathname has already been recorded on the full path name 4139aa23310Srie * AVL tree. This tree maintains a node for each path name that ld.so.1 has 4149aa23310Srie * successfully loaded. If the path name does not exist in this AVL tree, then 4159aa23310Srie * the next insertion point is deposited in "where". This value can be used by 4169aa23310Srie * fpavl_insert() to expedite the insertion. 4177c478bd9Sstevel@tonic-gate */ 4187c478bd9Sstevel@tonic-gate Rt_map * 41956deab07SRod Evans fpavl_recorded(Lm_list *lml, const char *name, uint_t hash, avl_index_t *where) 4207c478bd9Sstevel@tonic-gate { 4219aa23310Srie FullPathNode fpn, *fpnp; 4227c478bd9Sstevel@tonic-gate 4237c478bd9Sstevel@tonic-gate /* 4247c478bd9Sstevel@tonic-gate * Create the avl tree if required. 4257c478bd9Sstevel@tonic-gate */ 4263dbfc803SRod Evans if ((lml->lm_fpavl == NULL) && 4273dbfc803SRod Evans ((lml->lm_fpavl = pnavl_create(sizeof (FullPathNode))) == NULL)) 4283dbfc803SRod Evans return (NULL); 4297c478bd9Sstevel@tonic-gate 4309aa23310Srie fpn.fpn_node.pn_name = name; 43156deab07SRod Evans if ((fpn.fpn_node.pn_hash = hash) == 0) 43256deab07SRod Evans fpn.fpn_node.pn_hash = sgs_str_hash(name); 4337c478bd9Sstevel@tonic-gate 4347c478bd9Sstevel@tonic-gate if ((fpnp = avl_find(lml->lm_fpavl, &fpn, where)) == NULL) 4357c478bd9Sstevel@tonic-gate return (NULL); 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate return (fpnp->fpn_lmp); 4387c478bd9Sstevel@tonic-gate } 4397c478bd9Sstevel@tonic-gate 4407c478bd9Sstevel@tonic-gate /* 4419aa23310Srie * Insert a name into the FullPathNode AVL tree for the link-map list. The 44224a6229eSrie * objects NAME() is the path that would have originally been searched for, and 44324a6229eSrie * is therefore the name to associate with any "where" value. If the object has 4447c478bd9Sstevel@tonic-gate * a different PATHNAME(), perhaps because it has resolved to a different file 4459aa23310Srie * (see fullpath()), then this name will be recorded as a separate FullPathNode 4469aa23310Srie * (see load_file()). 4477c478bd9Sstevel@tonic-gate */ 4487c478bd9Sstevel@tonic-gate int 4497c478bd9Sstevel@tonic-gate fpavl_insert(Lm_list *lml, Rt_map *lmp, const char *name, avl_index_t where) 4507c478bd9Sstevel@tonic-gate { 4519aa23310Srie FullPathNode *fpnp; 45256deab07SRod Evans uint_t hash = sgs_str_hash(name); 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate if (where == 0) { 4557c478bd9Sstevel@tonic-gate /* LINTED */ 45656deab07SRod Evans Rt_map *_lmp = fpavl_recorded(lml, name, hash, &where); 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate /* 4597c478bd9Sstevel@tonic-gate * We better not get a hit now, we do not want duplicates in 4607c478bd9Sstevel@tonic-gate * the tree. 4617c478bd9Sstevel@tonic-gate */ 46243d7826aSRod Evans ASSERT(_lmp == NULL); 4637c478bd9Sstevel@tonic-gate } 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate /* 4669aa23310Srie * Insert new node in tree. 4677c478bd9Sstevel@tonic-gate */ 4683dbfc803SRod Evans if ((fpnp = calloc(sizeof (FullPathNode), 1)) == NULL) 4697c478bd9Sstevel@tonic-gate return (0); 4707c478bd9Sstevel@tonic-gate 4719aa23310Srie fpnp->fpn_node.pn_name = name; 47256deab07SRod Evans fpnp->fpn_node.pn_hash = hash; 4737c478bd9Sstevel@tonic-gate fpnp->fpn_lmp = lmp; 4747c478bd9Sstevel@tonic-gate 475cce0e03bSab if (aplist_append(&FPNODE(lmp), fpnp, AL_CNT_FPNODE) == NULL) { 4767c478bd9Sstevel@tonic-gate free(fpnp); 4777c478bd9Sstevel@tonic-gate return (0); 4787c478bd9Sstevel@tonic-gate } 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate ASSERT(lml->lm_fpavl != NULL); 4817c478bd9Sstevel@tonic-gate avl_insert(lml->lm_fpavl, fpnp, where); 4827c478bd9Sstevel@tonic-gate return (1); 4837c478bd9Sstevel@tonic-gate } 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate /* 48656deab07SRod Evans * Remove an object from the FullPathNode AVL tree. 4877c478bd9Sstevel@tonic-gate */ 4887c478bd9Sstevel@tonic-gate void 4897c478bd9Sstevel@tonic-gate fpavl_remove(Rt_map *lmp) 4907c478bd9Sstevel@tonic-gate { 4919aa23310Srie FullPathNode *fpnp; 492cce0e03bSab Aliste idx; 4937c478bd9Sstevel@tonic-gate 494cce0e03bSab for (APLIST_TRAVERSE(FPNODE(lmp), idx, fpnp)) { 4957c478bd9Sstevel@tonic-gate avl_remove(LIST(lmp)->lm_fpavl, fpnp); 4967c478bd9Sstevel@tonic-gate free(fpnp); 4977c478bd9Sstevel@tonic-gate } 4987c478bd9Sstevel@tonic-gate free(FPNODE(lmp)); 499cce0e03bSab FPNODE(lmp) = NULL; 5007c478bd9Sstevel@tonic-gate } 5017c478bd9Sstevel@tonic-gate 5029aa23310Srie /* 503*08278a5eSRod Evans * Insert a path name into the not-found AVL tree. 504*08278a5eSRod Evans * 5059aa23310Srie * This tree maintains a node for each path name that ld.so.1 has explicitly 5069aa23310Srie * inspected, but has failed to load during a single ld.so.1 operation. If the 5079aa23310Srie * path name does not exist in this AVL tree, then the next insertion point is 5089aa23310Srie * deposited in "where". This value can be used by nfavl_insert() to expedite 5099aa23310Srie * the insertion. 5109aa23310Srie */ 5119aa23310Srie void 5129aa23310Srie nfavl_insert(const char *name, avl_index_t where) 5139aa23310Srie { 5149aa23310Srie PathNode *pnp; 51556deab07SRod Evans uint_t hash = sgs_str_hash(name); 5169aa23310Srie 5179aa23310Srie if (where == 0) { 5189aa23310Srie /* LINTED */ 519*08278a5eSRod Evans int in_nfavl = pnavl_recorded(&nfavl, name, hash, &where); 5209aa23310Srie 5219aa23310Srie /* 5229aa23310Srie * We better not get a hit now, we do not want duplicates in 5239aa23310Srie * the tree. 5249aa23310Srie */ 5259aa23310Srie ASSERT(in_nfavl == 0); 5269aa23310Srie } 5279aa23310Srie 5289aa23310Srie /* 5299aa23310Srie * Insert new node in tree. 5309aa23310Srie */ 53156deab07SRod Evans if ((pnp = calloc(sizeof (PathNode), 1)) != NULL) { 5329aa23310Srie pnp->pn_name = name; 53356deab07SRod Evans pnp->pn_hash = hash; 5349aa23310Srie avl_insert(nfavl, pnp, where); 5359aa23310Srie } 5369aa23310Srie } 5377c478bd9Sstevel@tonic-gate 5383dbfc803SRod Evans /* 539*08278a5eSRod Evans * Insert the directory name, of a full path name, into the secure path AVL 5403dbfc803SRod Evans * tree. 541*08278a5eSRod Evans * 542*08278a5eSRod Evans * This tree is used to maintain a list of directories in which the dependencies 543*08278a5eSRod Evans * of a secure process have been found. This list provides a fall-back in the 544*08278a5eSRod Evans * case that a $ORIGIN expansion is deemed insecure, when the expansion results 545*08278a5eSRod Evans * in a path name that has already provided dependencies. 5463dbfc803SRod Evans */ 5473dbfc803SRod Evans void 5483dbfc803SRod Evans spavl_insert(const char *name) 5493dbfc803SRod Evans { 5503dbfc803SRod Evans char buffer[PATH_MAX], *str; 5513dbfc803SRod Evans size_t size; 5523dbfc803SRod Evans avl_index_t where; 5533dbfc803SRod Evans PathNode *pnp; 554*08278a5eSRod Evans uint_t hash; 5553dbfc803SRod Evans 5563dbfc803SRod Evans /* 5573dbfc803SRod Evans * Separate the directory name from the path name. 5583dbfc803SRod Evans */ 5593dbfc803SRod Evans if ((str = strrchr(name, '/')) == name) 5603dbfc803SRod Evans size = 1; 5613dbfc803SRod Evans else 5623dbfc803SRod Evans size = str - name; 5633dbfc803SRod Evans 5643dbfc803SRod Evans (void) strncpy(buffer, name, size); 5653dbfc803SRod Evans buffer[size] = '\0'; 566*08278a5eSRod Evans hash = sgs_str_hash(buffer); 5673dbfc803SRod Evans 5683dbfc803SRod Evans /* 5693dbfc803SRod Evans * Determine whether this directory name is already recorded, or if 5703dbfc803SRod Evans * not, 'where" will provide the insertion point for the new string. 5713dbfc803SRod Evans */ 572*08278a5eSRod Evans if (pnavl_recorded(&spavl, buffer, hash, &where)) 5733dbfc803SRod Evans return; 5743dbfc803SRod Evans 5753dbfc803SRod Evans /* 5763dbfc803SRod Evans * Insert new node in tree. 5773dbfc803SRod Evans */ 57843d7826aSRod Evans if ((pnp = calloc(sizeof (PathNode), 1)) != NULL) { 5793dbfc803SRod Evans pnp->pn_name = strdup(buffer); 580*08278a5eSRod Evans pnp->pn_hash = hash; 5813dbfc803SRod Evans avl_insert(spavl, pnp, where); 5823dbfc803SRod Evans } 5833dbfc803SRod Evans } 5843dbfc803SRod Evans 58556deab07SRod Evans /* 58656deab07SRod Evans * Inspect the generic string AVL tree for the given string. If the string is 58756deab07SRod Evans * not present, duplicate it, and insert the string in the AVL tree. Return the 58856deab07SRod Evans * duplicated string to the caller. 58956deab07SRod Evans * 59056deab07SRod Evans * These strings are maintained for the life of ld.so.1 and represent path 59156deab07SRod Evans * names, file names, and search paths. All other AVL trees that maintain 59256deab07SRod Evans * FullPathNode and not-found path names use the same string pointer 59356deab07SRod Evans * established for this string. 59456deab07SRod Evans */ 59556deab07SRod Evans static avl_tree_t *stravl = NULL; 59656deab07SRod Evans static char *strbuf = NULL; 59756deab07SRod Evans static PathNode *pnbuf = NULL; 59856deab07SRod Evans static size_t strsize = 0, pnsize = 0; 59956deab07SRod Evans 60056deab07SRod Evans const char * 60156deab07SRod Evans stravl_insert(const char *name, uint_t hash, size_t nsize, int substr) 60256deab07SRod Evans { 60356deab07SRod Evans char str[PATH_MAX]; 60456deab07SRod Evans PathNode *pnp; 60556deab07SRod Evans avl_index_t where; 60656deab07SRod Evans 60756deab07SRod Evans /* 60856deab07SRod Evans * Create the avl tree if required. 60956deab07SRod Evans */ 61056deab07SRod Evans if ((stravl == NULL) && 61156deab07SRod Evans ((stravl = pnavl_create(sizeof (PathNode))) == NULL)) 61256deab07SRod Evans return (NULL); 61356deab07SRod Evans 61456deab07SRod Evans /* 61556deab07SRod Evans * Determine the string size if not provided by the caller. 61656deab07SRod Evans */ 61756deab07SRod Evans if (nsize == 0) 61856deab07SRod Evans nsize = strlen(name) + 1; 61956deab07SRod Evans else if (substr) { 62056deab07SRod Evans /* 62156deab07SRod Evans * The string passed to us may be a multiple path string for 62256deab07SRod Evans * which we only need the first component. Using the provided 62356deab07SRod Evans * size, strip out the required string. 62456deab07SRod Evans */ 62556deab07SRod Evans (void) strncpy(str, name, nsize); 62656deab07SRod Evans str[nsize - 1] = '\0'; 62756deab07SRod Evans name = str; 62856deab07SRod Evans } 62956deab07SRod Evans 63056deab07SRod Evans /* 63156deab07SRod Evans * Allocate a PathNode buffer if one doesn't exist, or any existing 63256deab07SRod Evans * buffer has been used up. 63356deab07SRod Evans */ 63456deab07SRod Evans if ((pnbuf == NULL) || (sizeof (PathNode) > pnsize)) { 63556deab07SRod Evans pnsize = syspagsz; 63656deab07SRod Evans if ((pnbuf = dz_map(0, 0, pnsize, (PROT_READ | PROT_WRITE), 63756deab07SRod Evans MAP_PRIVATE)) == MAP_FAILED) 63856deab07SRod Evans return (NULL); 63956deab07SRod Evans } 64056deab07SRod Evans /* 64156deab07SRod Evans * Determine whether this string already exists. 64256deab07SRod Evans */ 64356deab07SRod Evans pnbuf->pn_name = name; 64456deab07SRod Evans if ((pnbuf->pn_hash = hash) == 0) 64556deab07SRod Evans pnbuf->pn_hash = sgs_str_hash(name); 64656deab07SRod Evans 64756deab07SRod Evans if ((pnp = avl_find(stravl, pnbuf, &where)) != NULL) 64856deab07SRod Evans return (pnp->pn_name); 64956deab07SRod Evans 65056deab07SRod Evans /* 65156deab07SRod Evans * Allocate a string buffer if one does not exist, or if there is 65256deab07SRod Evans * insufficient space for the new string in any existing buffer. 65356deab07SRod Evans */ 65456deab07SRod Evans if ((strbuf == NULL) || (nsize > strsize)) { 65556deab07SRod Evans strsize = S_ROUND(nsize, syspagsz); 65656deab07SRod Evans 65756deab07SRod Evans if ((strbuf = dz_map(0, 0, strsize, (PROT_READ | PROT_WRITE), 65856deab07SRod Evans MAP_PRIVATE)) == MAP_FAILED) 65956deab07SRod Evans return (NULL); 66056deab07SRod Evans } 66156deab07SRod Evans 66256deab07SRod Evans (void) memcpy(strbuf, name, nsize); 66356deab07SRod Evans pnp = pnbuf; 66456deab07SRod Evans pnp->pn_name = strbuf; 66556deab07SRod Evans avl_insert(stravl, pnp, where); 66656deab07SRod Evans 66756deab07SRod Evans strbuf += nsize; 66856deab07SRod Evans strsize -= nsize; 66956deab07SRod Evans pnbuf++; 67056deab07SRod Evans pnsize -= sizeof (PathNode); 67156deab07SRod Evans return (pnp->pn_name); 67256deab07SRod Evans } 67356deab07SRod Evans 6747c478bd9Sstevel@tonic-gate /* 6757c478bd9Sstevel@tonic-gate * Prior to calling an object, either via a .plt or through dlsym(), make sure 6767c478bd9Sstevel@tonic-gate * its .init has fired. Through topological sorting, ld.so.1 attempts to fire 6777c478bd9Sstevel@tonic-gate * init's in the correct order, however, this order is typically based on needed 6787c478bd9Sstevel@tonic-gate * dependencies and non-lazy relocation bindings. Lazy relocations (.plts) can 6797c478bd9Sstevel@tonic-gate * still occur and result in bindings that were not captured during topological 6807c478bd9Sstevel@tonic-gate * sorting. This routine compensates for this lack of binding information, and 6817c478bd9Sstevel@tonic-gate * provides for dynamic .init firing. 6827c478bd9Sstevel@tonic-gate */ 6837c478bd9Sstevel@tonic-gate void 6849aa23310Srie is_dep_init(Rt_map *dlmp, Rt_map *clmp) 6857c478bd9Sstevel@tonic-gate { 6869aa23310Srie Rt_map **tobj; 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate /* 6897c478bd9Sstevel@tonic-gate * If the caller is an auditor, and the destination isn't, then don't 6907c478bd9Sstevel@tonic-gate * run any .inits (see comments in load_completion()). 6917c478bd9Sstevel@tonic-gate */ 6927c478bd9Sstevel@tonic-gate if ((LIST(clmp)->lm_flags & LML_FLG_NOAUDIT) && 6937c478bd9Sstevel@tonic-gate (LIST(clmp) != LIST(dlmp))) 6947c478bd9Sstevel@tonic-gate return; 6957c478bd9Sstevel@tonic-gate 69656deab07SRod Evans if ((dlmp == clmp) || (rtld_flags & RT_FL_INITFIRST)) 6977c478bd9Sstevel@tonic-gate return; 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITDONE)) == 7007c478bd9Sstevel@tonic-gate (FLG_RT_RELOCED | FLG_RT_INITDONE)) 7017c478bd9Sstevel@tonic-gate return; 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITCALL)) == 7047c478bd9Sstevel@tonic-gate (FLG_RT_RELOCED | FLG_RT_INITCALL)) { 7055aefb655Srie DBG_CALL(Dbg_util_no_init(dlmp)); 7067c478bd9Sstevel@tonic-gate return; 7077c478bd9Sstevel@tonic-gate } 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate if ((tobj = calloc(2, sizeof (Rt_map *))) != NULL) { 7107c478bd9Sstevel@tonic-gate tobj[0] = dlmp; 7117c478bd9Sstevel@tonic-gate call_init(tobj, DBG_INIT_DYN); 7127c478bd9Sstevel@tonic-gate } 7137c478bd9Sstevel@tonic-gate } 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate /* 7167c478bd9Sstevel@tonic-gate * Execute .{preinit|init|fini}array sections 7177c478bd9Sstevel@tonic-gate */ 7187c478bd9Sstevel@tonic-gate void 7195aefb655Srie call_array(Addr *array, uint_t arraysz, Rt_map *lmp, Word shtype) 7207c478bd9Sstevel@tonic-gate { 7215aefb655Srie int start, stop, incr, ndx; 7227c478bd9Sstevel@tonic-gate uint_t arraycnt = (uint_t)(arraysz / sizeof (Addr)); 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate if (array == NULL) 7257c478bd9Sstevel@tonic-gate return; 7267c478bd9Sstevel@tonic-gate 7277c478bd9Sstevel@tonic-gate /* 7287c478bd9Sstevel@tonic-gate * initarray & preinitarray are walked from beginning to end - while 7297c478bd9Sstevel@tonic-gate * finiarray is walked from end to beginning. 7307c478bd9Sstevel@tonic-gate */ 7317c478bd9Sstevel@tonic-gate if (shtype == SHT_FINI_ARRAY) { 7327c478bd9Sstevel@tonic-gate start = arraycnt - 1; 7337c478bd9Sstevel@tonic-gate stop = incr = -1; 7347c478bd9Sstevel@tonic-gate } else { 7357c478bd9Sstevel@tonic-gate start = 0; 7367c478bd9Sstevel@tonic-gate stop = arraycnt; 7377c478bd9Sstevel@tonic-gate incr = 1; 7387c478bd9Sstevel@tonic-gate } 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate /* 7417c478bd9Sstevel@tonic-gate * Call the .*array[] entries 7427c478bd9Sstevel@tonic-gate */ 7435aefb655Srie for (ndx = start; ndx != stop; ndx += incr) { 74410a4fa49Srie void (*fptr)(void) = (void(*)())array[ndx]; 7457c478bd9Sstevel@tonic-gate 7465aefb655Srie DBG_CALL(Dbg_util_call_array(lmp, (void *)fptr, ndx, shtype)); 7477c478bd9Sstevel@tonic-gate 748eccf73c8Srie leave(LIST(lmp), 0); 7497c478bd9Sstevel@tonic-gate (*fptr)(); 750eccf73c8Srie (void) enter(0); 7517c478bd9Sstevel@tonic-gate } 7527c478bd9Sstevel@tonic-gate } 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate /* 7567c478bd9Sstevel@tonic-gate * Execute any .init sections. These are passed to us in an lmp array which 7577c478bd9Sstevel@tonic-gate * (by default) will have been sorted. 7587c478bd9Sstevel@tonic-gate */ 7597c478bd9Sstevel@tonic-gate void 7609aa23310Srie call_init(Rt_map **tobj, int flag) 7617c478bd9Sstevel@tonic-gate { 7629aa23310Srie Rt_map **_tobj, **_nobj; 76357ef7aa9SRod Evans static APlist *pending = NULL; 7647c478bd9Sstevel@tonic-gate 7657c478bd9Sstevel@tonic-gate /* 7667c478bd9Sstevel@tonic-gate * If we're in the middle of an INITFIRST, this must complete before 7677c478bd9Sstevel@tonic-gate * any new init's are fired. In this case add the object list to the 7687c478bd9Sstevel@tonic-gate * pending queue and return. We'll pick up the queue after any 7697c478bd9Sstevel@tonic-gate * INITFIRST objects have their init's fired. 7707c478bd9Sstevel@tonic-gate */ 7717c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_INITFIRST) { 77257ef7aa9SRod Evans (void) aplist_append(&pending, tobj, AL_CNT_PENDING); 7737c478bd9Sstevel@tonic-gate return; 7747c478bd9Sstevel@tonic-gate } 7757c478bd9Sstevel@tonic-gate 7767c478bd9Sstevel@tonic-gate /* 7777c478bd9Sstevel@tonic-gate * Traverse the tobj array firing each objects init. 7787c478bd9Sstevel@tonic-gate */ 7797c478bd9Sstevel@tonic-gate for (_tobj = _nobj = tobj, _nobj++; *_tobj != NULL; _tobj++, _nobj++) { 7809aa23310Srie Rt_map *lmp = *_tobj; 7819aa23310Srie void (*iptr)() = INIT(lmp); 782dde769a2SRod Evans uint_t rtldflags; 7837c478bd9Sstevel@tonic-gate 7847c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_INITCALL) 7857c478bd9Sstevel@tonic-gate continue; 7867c478bd9Sstevel@tonic-gate 7877c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_INITCALL; 7887c478bd9Sstevel@tonic-gate 789dde769a2SRod Evans /* 790dde769a2SRod Evans * It is possible, that during the initial handshake with libc, 791dde769a2SRod Evans * an interposition object has resolved a symbol binding, and 792dde769a2SRod Evans * that this objects .init must be fired. As we're about to 793dde769a2SRod Evans * run user code, make sure any dynamic linking errors remain 794dde769a2SRod Evans * internal (ie., only obtainable from dlerror()), and are not 795dde769a2SRod Evans * flushed to stderr. 796dde769a2SRod Evans */ 797dde769a2SRod Evans rtldflags = (rtld_flags & RT_FL_APPLIC) ? 0 : RT_FL_APPLIC; 798dde769a2SRod Evans rtld_flags |= rtldflags; 799dde769a2SRod Evans 8007c478bd9Sstevel@tonic-gate /* 8017c478bd9Sstevel@tonic-gate * Establish an initfirst state if necessary - no other inits 802dffec89cSrie * will be fired (because of additional relocation bindings) 803dffec89cSrie * when in this state. 8047c478bd9Sstevel@tonic-gate */ 8057c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_INITFRST) 8067c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_INITFIRST; 8077c478bd9Sstevel@tonic-gate 80856deab07SRod Evans if (INITARRAY(lmp) || iptr) 8095aefb655Srie DBG_CALL(Dbg_util_call_init(lmp, flag)); 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate if (iptr) { 812eccf73c8Srie leave(LIST(lmp), 0); 8137c478bd9Sstevel@tonic-gate (*iptr)(); 814eccf73c8Srie (void) enter(0); 8157c478bd9Sstevel@tonic-gate } 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate call_array(INITARRAY(lmp), INITARRAYSZ(lmp), lmp, 8187c478bd9Sstevel@tonic-gate SHT_INIT_ARRAY); 8197c478bd9Sstevel@tonic-gate 8207c478bd9Sstevel@tonic-gate if (INITARRAY(lmp) || iptr) 8215aefb655Srie DBG_CALL(Dbg_util_call_init(lmp, DBG_INIT_DONE)); 8227c478bd9Sstevel@tonic-gate 823dde769a2SRod Evans /* 824dde769a2SRod Evans * Return to a non-application setting if necessary. 825dde769a2SRod Evans */ 826dde769a2SRod Evans rtld_flags &= ~rtldflags; 827dde769a2SRod Evans 8287c478bd9Sstevel@tonic-gate /* 8297c478bd9Sstevel@tonic-gate * Set the initdone flag regardless of whether this object 8307c478bd9Sstevel@tonic-gate * actually contains an .init section. This flag prevents us 8317c478bd9Sstevel@tonic-gate * from processing this section again for an .init and also 8327c478bd9Sstevel@tonic-gate * signifies that a .fini must be called should it exist. 8337c478bd9Sstevel@tonic-gate * Clear the sort field for use in later .fini processing. 8347c478bd9Sstevel@tonic-gate */ 8357c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_INITDONE; 836dffec89cSrie SORTVAL(lmp) = -1; 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate /* 8397c478bd9Sstevel@tonic-gate * If we're firing an INITFIRST object, and other objects must 8407c478bd9Sstevel@tonic-gate * be fired which are not INITFIRST, make sure we grab any 8417c478bd9Sstevel@tonic-gate * pending objects that might have been delayed as this 8427c478bd9Sstevel@tonic-gate * INITFIRST was processed. 8437c478bd9Sstevel@tonic-gate */ 8447c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_INITFIRST) && 8457c478bd9Sstevel@tonic-gate ((*_nobj == NULL) || !(FLAGS(*_nobj) & FLG_RT_INITFRST))) { 84657ef7aa9SRod Evans Aliste idx; 84757ef7aa9SRod Evans Rt_map **pobj; 8487c478bd9Sstevel@tonic-gate 8497c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_INITFIRST; 8507c478bd9Sstevel@tonic-gate 85157ef7aa9SRod Evans for (APLIST_TRAVERSE(pending, idx, pobj)) { 85257ef7aa9SRod Evans aplist_delete(pending, &idx); 8537c478bd9Sstevel@tonic-gate call_init(pobj, DBG_INIT_PEND); 8547c478bd9Sstevel@tonic-gate } 8557c478bd9Sstevel@tonic-gate } 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate free(tobj); 8587c478bd9Sstevel@tonic-gate } 8597c478bd9Sstevel@tonic-gate 8607c478bd9Sstevel@tonic-gate /* 8617c478bd9Sstevel@tonic-gate * Function called by atexit(3C). Calls all .fini sections related with the 8627c478bd9Sstevel@tonic-gate * mains dependent shared libraries in the order in which the shared libraries 8637c478bd9Sstevel@tonic-gate * have been loaded. Skip any .fini defined in the main executable, as this 8647c478bd9Sstevel@tonic-gate * will be called by crt0 (main was never marked as initdone). 8657c478bd9Sstevel@tonic-gate */ 8667c478bd9Sstevel@tonic-gate void 8677c478bd9Sstevel@tonic-gate call_fini(Lm_list * lml, Rt_map ** tobj) 8687c478bd9Sstevel@tonic-gate { 869dffec89cSrie Rt_map **_tobj; 8707c478bd9Sstevel@tonic-gate 8717c478bd9Sstevel@tonic-gate for (_tobj = tobj; *_tobj != NULL; _tobj++) { 872cce0e03bSab Rt_map *clmp, * lmp = *_tobj; 873cce0e03bSab Aliste idx; 874cce0e03bSab Bnd_desc *bdp; 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate /* 87756deab07SRod Evans * Only fire a .fini if the objects corresponding .init has 87856deab07SRod Evans * completed. We collect all .fini sections of objects that 87956deab07SRod Evans * had their .init collected, but that doesn't mean that at 88056deab07SRod Evans * the time of collection, that the .init had completed. 8817c478bd9Sstevel@tonic-gate */ 88256deab07SRod Evans if (FLAGS(lmp) & FLG_RT_INITDONE) { 88310a4fa49Srie void (*fptr)(void) = FINI(lmp); 8847c478bd9Sstevel@tonic-gate 88556deab07SRod Evans if (FINIARRAY(lmp) || fptr) 8865aefb655Srie DBG_CALL(Dbg_util_call_fini(lmp)); 8877c478bd9Sstevel@tonic-gate 8885aefb655Srie call_array(FINIARRAY(lmp), FINIARRAYSZ(lmp), lmp, 8895aefb655Srie SHT_FINI_ARRAY); 8907c478bd9Sstevel@tonic-gate 8917c478bd9Sstevel@tonic-gate if (fptr) { 892eccf73c8Srie leave(LIST(lmp), 0); 8937c478bd9Sstevel@tonic-gate (*fptr)(); 894eccf73c8Srie (void) enter(0); 8957c478bd9Sstevel@tonic-gate } 8967c478bd9Sstevel@tonic-gate } 8977c478bd9Sstevel@tonic-gate 898dffec89cSrie /* 899dffec89cSrie * Skip main, this is explicitly called last in atexit_fini(). 900dffec89cSrie */ 901dffec89cSrie if (FLAGS(lmp) & FLG_RT_ISMAIN) 902dffec89cSrie continue; 903dffec89cSrie 9047c478bd9Sstevel@tonic-gate /* 9057c478bd9Sstevel@tonic-gate * Audit `close' operations at this point. The library has 9067c478bd9Sstevel@tonic-gate * exercised its last instructions (regardless of whether it 9077c478bd9Sstevel@tonic-gate * will be unmapped or not). 9087c478bd9Sstevel@tonic-gate * 9097c478bd9Sstevel@tonic-gate * First call any global auditing. 9107c478bd9Sstevel@tonic-gate */ 9117c478bd9Sstevel@tonic-gate if (lml->lm_tflags & LML_TFLG_AUD_OBJCLOSE) 91257ef7aa9SRod Evans _audit_objclose(auditors->ad_list, lmp); 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate /* 9157c478bd9Sstevel@tonic-gate * Finally determine whether this object has local auditing 9167c478bd9Sstevel@tonic-gate * requirements by inspecting itself and then its dependencies. 9177c478bd9Sstevel@tonic-gate */ 9187c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_LOCAUDIT) == 0) 9197c478bd9Sstevel@tonic-gate continue; 9207c478bd9Sstevel@tonic-gate 92156deab07SRod Evans if (AFLAGS(lmp) & LML_TFLG_AUD_OBJCLOSE) 92257ef7aa9SRod Evans _audit_objclose(AUDITORS(lmp)->ad_list, lmp); 9237c478bd9Sstevel@tonic-gate 924cce0e03bSab for (APLIST_TRAVERSE(CALLERS(lmp), idx, bdp)) { 9257c478bd9Sstevel@tonic-gate clmp = bdp->b_caller; 9267c478bd9Sstevel@tonic-gate 92756deab07SRod Evans if (AFLAGS(clmp) & LML_TFLG_AUD_OBJCLOSE) { 92857ef7aa9SRod Evans _audit_objclose(AUDITORS(clmp)->ad_list, lmp); 929a953e2b1Srie break; 9307c478bd9Sstevel@tonic-gate } 9317c478bd9Sstevel@tonic-gate } 9327c478bd9Sstevel@tonic-gate } 9335aefb655Srie DBG_CALL(Dbg_bind_plt_summary(lml, M_MACH, pltcnt21d, pltcnt24d, 9345aefb655Srie pltcntu32, pltcntu44, pltcntfull, pltcntfar)); 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate free(tobj); 9377c478bd9Sstevel@tonic-gate } 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate void 9407c478bd9Sstevel@tonic-gate atexit_fini() 9417c478bd9Sstevel@tonic-gate { 94257ef7aa9SRod Evans Rt_map **tobj, *lmp; 94357ef7aa9SRod Evans Lm_list *lml; 94457ef7aa9SRod Evans Aliste idx; 9457c478bd9Sstevel@tonic-gate 9468cd45542Sraf (void) enter(0); 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_ATEXIT; 9497c478bd9Sstevel@tonic-gate 9507c478bd9Sstevel@tonic-gate lml = &lml_main; 951dffec89cSrie lml->lm_flags |= LML_FLG_ATEXIT; 952883c6d49Srie lml->lm_flags &= ~LML_FLG_INTRPOSETSORT; 9537c478bd9Sstevel@tonic-gate lmp = (Rt_map *)lml->lm_head; 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate /* 9567c478bd9Sstevel@tonic-gate * Reverse topologically sort the main link-map for .fini execution. 9577c478bd9Sstevel@tonic-gate */ 95843d7826aSRod Evans if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != NULL) && 9597c478bd9Sstevel@tonic-gate (tobj != (Rt_map **)S_ERROR)) 9607c478bd9Sstevel@tonic-gate call_fini(lml, tobj); 9617c478bd9Sstevel@tonic-gate 9627c478bd9Sstevel@tonic-gate /* 963dffec89cSrie * Add an explicit close to main and ld.so.1. Although main's .fini is 964dffec89cSrie * collected in call_fini() to provide for FINITARRAY processing, its 965dffec89cSrie * audit_objclose is explicitly skipped. This provides for it to be 966dffec89cSrie * called last, here. This is the reverse of the explicit calls to 967dffec89cSrie * audit_objopen() made in setup(). 9687c478bd9Sstevel@tonic-gate */ 96956deab07SRod Evans if ((lml->lm_tflags | AFLAGS(lmp)) & LML_TFLG_AUD_MASK) { 9707c478bd9Sstevel@tonic-gate audit_objclose(lmp, (Rt_map *)lml_rtld.lm_head); 971dffec89cSrie audit_objclose(lmp, lmp); 9727c478bd9Sstevel@tonic-gate } 9737c478bd9Sstevel@tonic-gate 9747c478bd9Sstevel@tonic-gate /* 9757c478bd9Sstevel@tonic-gate * Now that all .fini code has been run, see what unreferenced objects 9769aa23310Srie * remain. 9777c478bd9Sstevel@tonic-gate */ 9787c478bd9Sstevel@tonic-gate unused(lml); 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate /* 9817c478bd9Sstevel@tonic-gate * Traverse any alternative link-map lists. 9827c478bd9Sstevel@tonic-gate */ 98357ef7aa9SRod Evans for (APLIST_TRAVERSE(dynlm_list, idx, lml)) { 98410a4fa49Srie /* 98510a4fa49Srie * Ignore the base-link-map list, which has already been 98610a4fa49Srie * processed, and the runtime linkers link-map list, which is 98710a4fa49Srie * typically processed last. 98810a4fa49Srie */ 9897c478bd9Sstevel@tonic-gate if (lml->lm_flags & (LML_FLG_BASELM | LML_FLG_RTLDLM)) 9907c478bd9Sstevel@tonic-gate continue; 9917c478bd9Sstevel@tonic-gate 99243d7826aSRod Evans if ((lmp = (Rt_map *)lml->lm_head) == NULL) 9937c478bd9Sstevel@tonic-gate continue; 9947c478bd9Sstevel@tonic-gate 995dffec89cSrie lml->lm_flags |= LML_FLG_ATEXIT; 996883c6d49Srie lml->lm_flags &= ~LML_FLG_INTRPOSETSORT; 997dffec89cSrie 9987c478bd9Sstevel@tonic-gate /* 9997c478bd9Sstevel@tonic-gate * Reverse topologically sort the link-map for .fini execution. 10007c478bd9Sstevel@tonic-gate */ 100143d7826aSRod Evans if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != NULL) && 10027c478bd9Sstevel@tonic-gate (tobj != (Rt_map **)S_ERROR)) 10037c478bd9Sstevel@tonic-gate call_fini(lml, tobj); 10047c478bd9Sstevel@tonic-gate 10057c478bd9Sstevel@tonic-gate unused(lml); 10067c478bd9Sstevel@tonic-gate } 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate /* 10097c478bd9Sstevel@tonic-gate * Finally reverse topologically sort the runtime linkers link-map for 10107c478bd9Sstevel@tonic-gate * .fini execution. 10117c478bd9Sstevel@tonic-gate */ 10127c478bd9Sstevel@tonic-gate lml = &lml_rtld; 1013dffec89cSrie lml->lm_flags |= LML_FLG_ATEXIT; 1014883c6d49Srie lml->lm_flags &= ~LML_FLG_INTRPOSETSORT; 10157c478bd9Sstevel@tonic-gate lmp = (Rt_map *)lml->lm_head; 10167c478bd9Sstevel@tonic-gate 101743d7826aSRod Evans if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != NULL) && 10187c478bd9Sstevel@tonic-gate (tobj != (Rt_map **)S_ERROR)) 10197c478bd9Sstevel@tonic-gate call_fini(lml, tobj); 10207c478bd9Sstevel@tonic-gate 10218cd45542Sraf leave(&lml_main, 0); 10227c478bd9Sstevel@tonic-gate } 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate 10257c478bd9Sstevel@tonic-gate /* 10267c478bd9Sstevel@tonic-gate * This routine is called to complete any runtime linker activity which may have 10277c478bd9Sstevel@tonic-gate * resulted in objects being loaded. This is called from all user entry points 10287c478bd9Sstevel@tonic-gate * and from any internal dl*() requests. 10297c478bd9Sstevel@tonic-gate */ 10307c478bd9Sstevel@tonic-gate void 10317247f888Srie load_completion(Rt_map *nlmp) 10327c478bd9Sstevel@tonic-gate { 103343d7826aSRod Evans Rt_map **tobj = NULL; 10347247f888Srie Lm_list *nlml; 10357c478bd9Sstevel@tonic-gate 10367c478bd9Sstevel@tonic-gate /* 10377c478bd9Sstevel@tonic-gate * Establish any .init processing. Note, in a world of lazy loading, 10387c478bd9Sstevel@tonic-gate * objects may have been loaded regardless of whether the users request 10397c478bd9Sstevel@tonic-gate * was fulfilled (i.e., a dlsym() request may have failed to find a 10407c478bd9Sstevel@tonic-gate * symbol but objects might have been loaded during its search). Thus, 10417c478bd9Sstevel@tonic-gate * any tsorting starts from the nlmp (new link-maps) pointer and not 10427c478bd9Sstevel@tonic-gate * necessarily from the link-map that may have satisfied the request. 10437c478bd9Sstevel@tonic-gate * 104410a4fa49Srie * Note, the primary link-map has an initialization phase where dynamic 104510a4fa49Srie * .init firing is suppressed. This provides for a simple and clean 104610a4fa49Srie * handshake with the primary link-maps libc, which is important for 104710a4fa49Srie * establishing uberdata. In addition, auditors often obtain handles 104810a4fa49Srie * to primary link-map objects as the objects are loaded, so as to 104910a4fa49Srie * inspect the link-map for symbols. This inspection is allowed without 105010a4fa49Srie * running any code on the primary link-map, as running this code may 105110a4fa49Srie * reenter the auditor, who may not yet have finished its own 10527c478bd9Sstevel@tonic-gate * initialization. 10537c478bd9Sstevel@tonic-gate */ 105410a4fa49Srie if (nlmp) 105510a4fa49Srie nlml = LIST(nlmp); 105610a4fa49Srie 1057b71d513aSedp if (nlmp && nlml->lm_init && ((nlml != &lml_main) || 1058b71d513aSedp (rtld_flags2 & (RT_FL2_PLMSETUP | RT_FL2_NOPLM)))) { 105956deab07SRod Evans if ((tobj = tsort(nlmp, nlml->lm_init, 1060dffec89cSrie RT_SORT_REV)) == (Rt_map **)S_ERROR) 106143d7826aSRod Evans tobj = NULL; 10627c478bd9Sstevel@tonic-gate } 10637c478bd9Sstevel@tonic-gate 106410a4fa49Srie /* 106510a4fa49Srie * Make sure any alternative link-map retrieves any external interfaces 106610a4fa49Srie * and initializes threads. 106710a4fa49Srie */ 106810a4fa49Srie if (nlmp && (nlml != &lml_main)) { 106910a4fa49Srie (void) rt_get_extern(nlml, nlmp); 107010a4fa49Srie rt_thr_init(nlml); 107110a4fa49Srie } 107210a4fa49Srie 107310a4fa49Srie /* 107410a4fa49Srie * Traverse the list of new link-maps and register any dynamic TLS. 107510a4fa49Srie * This storage is established for any objects not on the primary 107610a4fa49Srie * link-map, and for any objects added to the primary link-map after 107710a4fa49Srie * static TLS has been registered. 107810a4fa49Srie */ 1079b71d513aSedp if (nlmp && nlml->lm_tls && ((nlml != &lml_main) || 1080b71d513aSedp (rtld_flags2 & (RT_FL2_PLMSETUP | RT_FL2_NOPLM)))) { 108110a4fa49Srie Rt_map *lmp; 108210a4fa49Srie 1083cb511613SAli Bahrami for (lmp = nlmp; lmp; lmp = NEXT_RT_MAP(lmp)) { 108410a4fa49Srie if (PTTLS(lmp) && PTTLS(lmp)->p_memsz) 108510a4fa49Srie tls_modaddrem(lmp, TM_FLG_MODADD); 108610a4fa49Srie } 108710a4fa49Srie nlml->lm_tls = 0; 108810a4fa49Srie } 108910a4fa49Srie 10907c478bd9Sstevel@tonic-gate /* 10917c478bd9Sstevel@tonic-gate * Fire any .init's. 10927c478bd9Sstevel@tonic-gate */ 10937c478bd9Sstevel@tonic-gate if (tobj) 10947c478bd9Sstevel@tonic-gate call_init(tobj, DBG_INIT_SORT); 10957c478bd9Sstevel@tonic-gate } 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate /* 10987c478bd9Sstevel@tonic-gate * Append an item to the specified link map control list. 10997c478bd9Sstevel@tonic-gate */ 11007c478bd9Sstevel@tonic-gate void 11017c478bd9Sstevel@tonic-gate lm_append(Lm_list *lml, Aliste lmco, Rt_map *lmp) 11027c478bd9Sstevel@tonic-gate { 11037c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 11047c478bd9Sstevel@tonic-gate int add = 1; 11057c478bd9Sstevel@tonic-gate 11067c478bd9Sstevel@tonic-gate /* 11077c478bd9Sstevel@tonic-gate * Indicate that this link-map list has a new object. 11087c478bd9Sstevel@tonic-gate */ 11097c478bd9Sstevel@tonic-gate (lml->lm_obj)++; 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate /* 111212b8e62eSrie * If we're about to add a new object to the main link-map control list, 111312b8e62eSrie * alert the debuggers that we are about to mess with this list. 111412b8e62eSrie * Additions of individual objects to the main link-map control list 111512b8e62eSrie * occur during initial setup as the applications immediate dependencies 111612b8e62eSrie * are loaded. Individual objects are also loaded on the main link-map 111712b8e62eSrie * control list of new alternative link-map control lists. 11187c478bd9Sstevel@tonic-gate */ 1119cce0e03bSab if ((lmco == ALIST_OFF_DATA) && 1120cce0e03bSab ((lml->lm_flags & LML_FLG_DBNOTIF) == 0)) 112112b8e62eSrie rd_event(lml, RD_DLACTIVITY, RT_ADD); 11227c478bd9Sstevel@tonic-gate 11237c478bd9Sstevel@tonic-gate /* LINTED */ 1124cce0e03bSab lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, lmco); 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate /* 11277c478bd9Sstevel@tonic-gate * A link-map list header points to one of more link-map control lists 11287c478bd9Sstevel@tonic-gate * (see include/rtld.h). The initial list, pointed to by lm_cntl, is 11297c478bd9Sstevel@tonic-gate * the list of relocated objects. Other lists maintain objects that 11307c478bd9Sstevel@tonic-gate * are still being analyzed or relocated. This list provides the core 11317c478bd9Sstevel@tonic-gate * link-map list information used by all ld.so.1 routines. 11327c478bd9Sstevel@tonic-gate */ 11337c478bd9Sstevel@tonic-gate if (lmc->lc_head == NULL) { 11347c478bd9Sstevel@tonic-gate /* 11357c478bd9Sstevel@tonic-gate * If this is the first link-map for the given control list, 11367c478bd9Sstevel@tonic-gate * initialize the list. 11377c478bd9Sstevel@tonic-gate */ 11387c478bd9Sstevel@tonic-gate lmc->lc_head = lmc->lc_tail = lmp; 11397c478bd9Sstevel@tonic-gate add = 0; 11407c478bd9Sstevel@tonic-gate 11419a411307Srie } else if (FLAGS(lmp) & FLG_RT_OBJINTPO) { 11427c478bd9Sstevel@tonic-gate Rt_map *tlmp; 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate /* 11457c478bd9Sstevel@tonic-gate * If this is an interposer then append the link-map following 11467c478bd9Sstevel@tonic-gate * any other interposers (these are objects that have been 11477c478bd9Sstevel@tonic-gate * previously preloaded, or were identified with -z interpose). 11487c478bd9Sstevel@tonic-gate * Interposers can only be inserted on the first link-map 11497c478bd9Sstevel@tonic-gate * control list, as once relocation has started, interposition 11507c478bd9Sstevel@tonic-gate * from new interposers can't be guaranteed. 11517c478bd9Sstevel@tonic-gate * 11527c478bd9Sstevel@tonic-gate * NOTE: We do not interpose on the head of a list. This model 11537c478bd9Sstevel@tonic-gate * evolved because dynamic executables have already been fully 11547c478bd9Sstevel@tonic-gate * relocated within themselves and thus can't be interposed on. 11557c478bd9Sstevel@tonic-gate * Nowadays it's possible to have shared objects at the head of 11567c478bd9Sstevel@tonic-gate * a list, which conceptually means they could be interposed on. 11577c478bd9Sstevel@tonic-gate * But, shared objects can be created via dldump() and may only 11587c478bd9Sstevel@tonic-gate * be partially relocated (just relatives), in which case they 11597c478bd9Sstevel@tonic-gate * are interposable, but are marked as fixed (ET_EXEC). 11607c478bd9Sstevel@tonic-gate * 11617c478bd9Sstevel@tonic-gate * Thus we really don't have a clear method of deciding when the 11627c478bd9Sstevel@tonic-gate * head of a link-map is interposable. So, to be consistent, 11637c478bd9Sstevel@tonic-gate * for now only add interposers after the link-map lists head 11647c478bd9Sstevel@tonic-gate * object. 11657c478bd9Sstevel@tonic-gate */ 1166cb511613SAli Bahrami for (tlmp = NEXT_RT_MAP(lmc->lc_head); tlmp; 1167cb511613SAli Bahrami tlmp = NEXT_RT_MAP(tlmp)) { 11687c478bd9Sstevel@tonic-gate 11699a411307Srie if (FLAGS(tlmp) & FLG_RT_OBJINTPO) 11707c478bd9Sstevel@tonic-gate continue; 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate /* 11737c478bd9Sstevel@tonic-gate * Insert the new link-map before this non-interposer, 11747c478bd9Sstevel@tonic-gate * and indicate an interposer is found. 11757c478bd9Sstevel@tonic-gate */ 1176cb511613SAli Bahrami NEXT(PREV_RT_MAP(tlmp)) = (Link_map *)lmp; 11777c478bd9Sstevel@tonic-gate PREV(lmp) = PREV(tlmp); 11787c478bd9Sstevel@tonic-gate 11797c478bd9Sstevel@tonic-gate NEXT(lmp) = (Link_map *)tlmp; 11807c478bd9Sstevel@tonic-gate PREV(tlmp) = (Link_map *)lmp; 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate lmc->lc_flags |= LMC_FLG_REANALYZE; 11837c478bd9Sstevel@tonic-gate add = 0; 11847c478bd9Sstevel@tonic-gate break; 11857c478bd9Sstevel@tonic-gate } 11867c478bd9Sstevel@tonic-gate } 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate /* 11897c478bd9Sstevel@tonic-gate * Fall through to appending the new link map to the tail of the list. 11907c478bd9Sstevel@tonic-gate * If we're processing the initial objects of this link-map list, add 11917c478bd9Sstevel@tonic-gate * them to the backward compatibility list. 11927c478bd9Sstevel@tonic-gate */ 11937c478bd9Sstevel@tonic-gate if (add) { 11947c478bd9Sstevel@tonic-gate NEXT(lmc->lc_tail) = (Link_map *)lmp; 11957c478bd9Sstevel@tonic-gate PREV(lmp) = (Link_map *)lmc->lc_tail; 11967c478bd9Sstevel@tonic-gate lmc->lc_tail = lmp; 11977c478bd9Sstevel@tonic-gate } 11987c478bd9Sstevel@tonic-gate 11997c478bd9Sstevel@tonic-gate /* 12007c478bd9Sstevel@tonic-gate * Having added this link-map to a control list, indicate which control 12017c478bd9Sstevel@tonic-gate * list the link-map belongs to. Note, control list information is 12027c478bd9Sstevel@tonic-gate * always maintained as an offset, as the Alist can be reallocated. 12037c478bd9Sstevel@tonic-gate */ 12047c478bd9Sstevel@tonic-gate CNTL(lmp) = lmco; 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate /* 12077c478bd9Sstevel@tonic-gate * Indicate if an interposer is found. Note that the first object on a 12087c478bd9Sstevel@tonic-gate * link-map can be explicitly defined as an interposer so that it can 12097c478bd9Sstevel@tonic-gate * provide interposition over direct binding requests. 12107c478bd9Sstevel@tonic-gate */ 12119a411307Srie if (FLAGS(lmp) & MSK_RT_INTPOSE) 12127c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_INTRPOSE; 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate /* 12157c478bd9Sstevel@tonic-gate * For backward compatibility with debuggers, the link-map list contains 12167c478bd9Sstevel@tonic-gate * pointers to the main control list. 12177c478bd9Sstevel@tonic-gate */ 1218cce0e03bSab if (lmco == ALIST_OFF_DATA) { 12197c478bd9Sstevel@tonic-gate lml->lm_head = lmc->lc_head; 12207c478bd9Sstevel@tonic-gate lml->lm_tail = lmc->lc_tail; 12217c478bd9Sstevel@tonic-gate } 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate 12247c478bd9Sstevel@tonic-gate /* 12257c478bd9Sstevel@tonic-gate * Delete an item from the specified link map control list. 12267c478bd9Sstevel@tonic-gate */ 12277c478bd9Sstevel@tonic-gate void 12287c478bd9Sstevel@tonic-gate lm_delete(Lm_list *lml, Rt_map *lmp) 12297c478bd9Sstevel@tonic-gate { 12307c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 12317c478bd9Sstevel@tonic-gate 12327c478bd9Sstevel@tonic-gate /* 12337c478bd9Sstevel@tonic-gate * If the control list pointer hasn't been initialized, this object 12347c478bd9Sstevel@tonic-gate * never got added to a link-map list. 12357c478bd9Sstevel@tonic-gate */ 12367c478bd9Sstevel@tonic-gate if (CNTL(lmp) == 0) 12377c478bd9Sstevel@tonic-gate return; 12387c478bd9Sstevel@tonic-gate 12397c478bd9Sstevel@tonic-gate /* 124012b8e62eSrie * If we're about to delete an object from the main link-map control 124112b8e62eSrie * list, alert the debuggers that we are about to mess with this list. 12427c478bd9Sstevel@tonic-gate */ 1243cce0e03bSab if ((CNTL(lmp) == ALIST_OFF_DATA) && 1244cce0e03bSab ((lml->lm_flags & LML_FLG_DBNOTIF) == 0)) 12457c478bd9Sstevel@tonic-gate rd_event(lml, RD_DLACTIVITY, RT_DELETE); 12467c478bd9Sstevel@tonic-gate 12477c478bd9Sstevel@tonic-gate /* LINTED */ 1248cce0e03bSab lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, CNTL(lmp)); 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate if (lmc->lc_head == lmp) 1251cb511613SAli Bahrami lmc->lc_head = NEXT_RT_MAP(lmp); 12527c478bd9Sstevel@tonic-gate else 1253cb511613SAli Bahrami NEXT(PREV_RT_MAP(lmp)) = (void *)NEXT(lmp); 12547c478bd9Sstevel@tonic-gate 12557c478bd9Sstevel@tonic-gate if (lmc->lc_tail == lmp) 1256cb511613SAli Bahrami lmc->lc_tail = PREV_RT_MAP(lmp); 12577c478bd9Sstevel@tonic-gate else 1258cb511613SAli Bahrami PREV(NEXT_RT_MAP(lmp)) = PREV(lmp); 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate /* 12617c478bd9Sstevel@tonic-gate * For backward compatibility with debuggers, the link-map list contains 12627c478bd9Sstevel@tonic-gate * pointers to the main control list. 12637c478bd9Sstevel@tonic-gate */ 1264cce0e03bSab if (lmc == (Lm_cntl *)&lml->lm_lists->al_data) { 12657c478bd9Sstevel@tonic-gate lml->lm_head = lmc->lc_head; 12667c478bd9Sstevel@tonic-gate lml->lm_tail = lmc->lc_tail; 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate /* 12707c478bd9Sstevel@tonic-gate * Indicate we have one less object on this control list. 12717c478bd9Sstevel@tonic-gate */ 12727c478bd9Sstevel@tonic-gate (lml->lm_obj)--; 12737c478bd9Sstevel@tonic-gate } 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate /* 12767c478bd9Sstevel@tonic-gate * Move a link-map control list to another. Objects that are being relocated 12777c478bd9Sstevel@tonic-gate * are maintained on secondary control lists. Once their relocation is 12787c478bd9Sstevel@tonic-gate * complete, the entire list is appended to the previous control list, as this 12797c478bd9Sstevel@tonic-gate * list must have been the trigger for generating the new control list. 12807c478bd9Sstevel@tonic-gate */ 12817c478bd9Sstevel@tonic-gate void 12827c478bd9Sstevel@tonic-gate lm_move(Lm_list *lml, Aliste nlmco, Aliste plmco, Lm_cntl *nlmc, Lm_cntl *plmc) 12837c478bd9Sstevel@tonic-gate { 12847c478bd9Sstevel@tonic-gate Rt_map *lmp; 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate /* 128712b8e62eSrie * If we're about to add a new family of objects to the main link-map 128812b8e62eSrie * control list, alert the debuggers that we are about to mess with this 128912b8e62eSrie * list. Additions of object families to the main link-map control 129012b8e62eSrie * list occur during lazy loading, filtering and dlopen(). 12917c478bd9Sstevel@tonic-gate */ 1292cce0e03bSab if ((plmco == ALIST_OFF_DATA) && 1293cce0e03bSab ((lml->lm_flags & LML_FLG_DBNOTIF) == 0)) 12947c478bd9Sstevel@tonic-gate rd_event(lml, RD_DLACTIVITY, RT_ADD); 12957c478bd9Sstevel@tonic-gate 129612b8e62eSrie DBG_CALL(Dbg_file_cntl(lml, nlmco, plmco)); 129712b8e62eSrie 12987c478bd9Sstevel@tonic-gate /* 12997c478bd9Sstevel@tonic-gate * Indicate each new link-map has been moved to the previous link-map 13007c478bd9Sstevel@tonic-gate * control list. 13017c478bd9Sstevel@tonic-gate */ 130256deab07SRod Evans for (lmp = nlmc->lc_head; lmp; lmp = NEXT_RT_MAP(lmp)) { 13037c478bd9Sstevel@tonic-gate CNTL(lmp) = plmco; 13047c478bd9Sstevel@tonic-gate 130556deab07SRod Evans /* 130656deab07SRod Evans * If these objects are being added to the main link-map 130756deab07SRod Evans * control list, indicate that there are init's available 130856deab07SRod Evans * for harvesting. 130956deab07SRod Evans */ 131056deab07SRod Evans if (plmco == ALIST_OFF_DATA) { 131156deab07SRod Evans lml->lm_init++; 131256deab07SRod Evans lml->lm_flags |= LML_FLG_OBJADDED; 131356deab07SRod Evans } 131456deab07SRod Evans } 131556deab07SRod Evans 13167c478bd9Sstevel@tonic-gate /* 13177c478bd9Sstevel@tonic-gate * Move the new link-map control list, to the callers link-map control 13187c478bd9Sstevel@tonic-gate * list. 13197c478bd9Sstevel@tonic-gate */ 13203dbfc803SRod Evans if (plmc->lc_head == NULL) { 13217c478bd9Sstevel@tonic-gate plmc->lc_head = nlmc->lc_head; 13223dbfc803SRod Evans PREV(nlmc->lc_head) = NULL; 13237c478bd9Sstevel@tonic-gate } else { 13247c478bd9Sstevel@tonic-gate NEXT(plmc->lc_tail) = (Link_map *)nlmc->lc_head; 13257c478bd9Sstevel@tonic-gate PREV(nlmc->lc_head) = (Link_map *)plmc->lc_tail; 13267c478bd9Sstevel@tonic-gate } 13277c478bd9Sstevel@tonic-gate 13287c478bd9Sstevel@tonic-gate plmc->lc_tail = nlmc->lc_tail; 13293dbfc803SRod Evans nlmc->lc_head = nlmc->lc_tail = NULL; 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate /* 13327c478bd9Sstevel@tonic-gate * For backward compatibility with debuggers, the link-map list contains 13337c478bd9Sstevel@tonic-gate * pointers to the main control list. 13347c478bd9Sstevel@tonic-gate */ 1335cce0e03bSab if (plmco == ALIST_OFF_DATA) { 13367c478bd9Sstevel@tonic-gate lml->lm_head = plmc->lc_head; 13377c478bd9Sstevel@tonic-gate lml->lm_tail = plmc->lc_tail; 13387c478bd9Sstevel@tonic-gate } 13397c478bd9Sstevel@tonic-gate } 13407c478bd9Sstevel@tonic-gate 1341dde769a2SRod Evans /* 1342dde769a2SRod Evans * Create, or assign a link-map control list. Each link-map list contains a 1343dde769a2SRod Evans * main control list, which has an Alist offset of ALIST_OFF_DATA (see the 1344dde769a2SRod Evans * description in include/rtld.h). During the initial construction of a 1345dde769a2SRod Evans * process, objects are added to this main control list. This control list is 1346dde769a2SRod Evans * never deleted, unless an alternate link-map list has been requested (say for 1347dde769a2SRod Evans * auditors), and the associated objects could not be loaded or relocated. 1348dde769a2SRod Evans * 1349dde769a2SRod Evans * Once relocation has started, any lazy loadable objects, or filtees, are 1350dde769a2SRod Evans * processed on a new, temporary control list. Only when these objects have 1351dde769a2SRod Evans * been fully relocated, are they moved to the main link-map control list. 1352dde769a2SRod Evans * Once the objects are moved, this temporary control list is deleted (see 1353dde769a2SRod Evans * remove_cntl()). 1354dde769a2SRod Evans * 1355dde769a2SRod Evans * A dlopen() always requires a new temporary link-map control list. 1356dde769a2SRod Evans * Typically, a dlopen() occurs on a link-map list that had already started 1357dde769a2SRod Evans * relocation, however, auditors can dlopen() objects on the main link-map 1358dde769a2SRod Evans * list while under initial construction, before any relocation has begun. 1359dde769a2SRod Evans * Hence, dlopen() requests are explicitly flagged. 1360dde769a2SRod Evans */ 1361dde769a2SRod Evans Aliste 1362dde769a2SRod Evans create_cntl(Lm_list *lml, int dlopen) 1363dde769a2SRod Evans { 1364dde769a2SRod Evans /* 1365dde769a2SRod Evans * If the head link-map object has already been relocated, create a 1366dde769a2SRod Evans * new, temporary, control list. 1367dde769a2SRod Evans */ 1368dde769a2SRod Evans if (dlopen || (lml->lm_head == NULL) || 1369dde769a2SRod Evans (FLAGS(lml->lm_head) & FLG_RT_RELOCED)) { 1370dde769a2SRod Evans Lm_cntl *lmc; 1371dde769a2SRod Evans 1372dde769a2SRod Evans if ((lmc = alist_append(&lml->lm_lists, NULL, sizeof (Lm_cntl), 1373dde769a2SRod Evans AL_CNT_LMLISTS)) == NULL) 1374dde769a2SRod Evans return (NULL); 1375dde769a2SRod Evans 1376dde769a2SRod Evans return ((Aliste)((char *)lmc - (char *)lml->lm_lists)); 1377dde769a2SRod Evans } 1378dde769a2SRod Evans 1379dde769a2SRod Evans return (ALIST_OFF_DATA); 1380dde769a2SRod Evans } 1381dde769a2SRod Evans 13827c478bd9Sstevel@tonic-gate /* 13837c478bd9Sstevel@tonic-gate * Environment variables can have a variety of defined permutations, and thus 13847c478bd9Sstevel@tonic-gate * the following infrastructure exists to allow this variety and to select the 13857c478bd9Sstevel@tonic-gate * required definition. 13867c478bd9Sstevel@tonic-gate * 13877c478bd9Sstevel@tonic-gate * Environment variables can be defined as 32- or 64-bit specific, and if so 13887c478bd9Sstevel@tonic-gate * they will take precedence over any instruction set neutral form. Typically 13897c478bd9Sstevel@tonic-gate * this is only useful when the environment value is an informational string. 13907c478bd9Sstevel@tonic-gate * 13917c478bd9Sstevel@tonic-gate * Environment variables may be obtained from the standard user environment or 13927c478bd9Sstevel@tonic-gate * from a configuration file. The latter provides a fallback if no user 13937c478bd9Sstevel@tonic-gate * environment setting is found, and can take two forms: 13947c478bd9Sstevel@tonic-gate * 139543d7826aSRod Evans * - a replaceable definition - this will be used if no user environment 13967c478bd9Sstevel@tonic-gate * setting has been seen, or 13977c478bd9Sstevel@tonic-gate * 139843d7826aSRod Evans * - an permanent definition - this will be used no matter what user 13997c478bd9Sstevel@tonic-gate * environment setting is seen. In the case of list variables it will be 14007c478bd9Sstevel@tonic-gate * appended to any process environment setting seen. 14017c478bd9Sstevel@tonic-gate * 14027c478bd9Sstevel@tonic-gate * Environment variables can be defined without a value (ie. LD_XXXX=) so as to 14037c478bd9Sstevel@tonic-gate * override any replaceable environment variables from a configuration file. 14047c478bd9Sstevel@tonic-gate */ 14057c478bd9Sstevel@tonic-gate static u_longlong_t rplgen; /* replaceable generic */ 14067c478bd9Sstevel@tonic-gate /* variables */ 14077c478bd9Sstevel@tonic-gate static u_longlong_t rplisa; /* replaceable ISA specific */ 14087c478bd9Sstevel@tonic-gate /* variables */ 14097c478bd9Sstevel@tonic-gate static u_longlong_t prmgen; /* permanent generic */ 14107c478bd9Sstevel@tonic-gate /* variables */ 14117c478bd9Sstevel@tonic-gate static u_longlong_t prmisa; /* permanent ISA specific */ 14127c478bd9Sstevel@tonic-gate /* variables */ 14137c478bd9Sstevel@tonic-gate 14147c478bd9Sstevel@tonic-gate /* 14157c478bd9Sstevel@tonic-gate * Classify an environment variables type. 14167c478bd9Sstevel@tonic-gate */ 14177c478bd9Sstevel@tonic-gate #define ENV_TYP_IGNORE 0x1 /* ignore - variable is for */ 14187c478bd9Sstevel@tonic-gate /* the wrong ISA */ 14197c478bd9Sstevel@tonic-gate #define ENV_TYP_ISA 0x2 /* variable is ISA specific */ 14207c478bd9Sstevel@tonic-gate #define ENV_TYP_CONFIG 0x4 /* variable obtained from a */ 14217c478bd9Sstevel@tonic-gate /* config file */ 14227c478bd9Sstevel@tonic-gate #define ENV_TYP_PERMANT 0x8 /* variable is permanent */ 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate /* 14257c478bd9Sstevel@tonic-gate * Identify all environment variables. 14267c478bd9Sstevel@tonic-gate */ 1427*08278a5eSRod Evans #define ENV_FLG_AUDIT 0x0000000000001ULL 1428*08278a5eSRod Evans #define ENV_FLG_AUDIT_ARGS 0x0000000000002ULL 1429*08278a5eSRod Evans #define ENV_FLG_BIND_NOW 0x0000000000004ULL 1430*08278a5eSRod Evans #define ENV_FLG_BIND_NOT 0x0000000000008ULL 1431*08278a5eSRod Evans #define ENV_FLG_BINDINGS 0x0000000000010ULL 1432*08278a5eSRod Evans #define ENV_FLG_CONFGEN 0x0000000000020ULL 1433*08278a5eSRod Evans #define ENV_FLG_CONFIG 0x0000000000040ULL 1434*08278a5eSRod Evans #define ENV_FLG_DEBUG 0x0000000000080ULL 1435*08278a5eSRod Evans #define ENV_FLG_DEBUG_OUTPUT 0x0000000000100ULL 1436*08278a5eSRod Evans #define ENV_FLG_DEMANGLE 0x0000000000200ULL 1437*08278a5eSRod Evans #define ENV_FLG_FLAGS 0x0000000000400ULL 1438*08278a5eSRod Evans #define ENV_FLG_INIT 0x0000000000800ULL 1439*08278a5eSRod Evans #define ENV_FLG_LIBPATH 0x0000000001000ULL 1440*08278a5eSRod Evans #define ENV_FLG_LOADAVAIL 0x0000000002000ULL 1441*08278a5eSRod Evans #define ENV_FLG_LOADFLTR 0x0000000004000ULL 1442*08278a5eSRod Evans #define ENV_FLG_NOAUDIT 0x0000000008000ULL 1443*08278a5eSRod Evans #define ENV_FLG_NOAUXFLTR 0x0000000010000ULL 1444*08278a5eSRod Evans #define ENV_FLG_NOBAPLT 0x0000000020000ULL 1445*08278a5eSRod Evans #define ENV_FLG_NOCONFIG 0x0000000040000ULL 1446*08278a5eSRod Evans #define ENV_FLG_NODIRCONFIG 0x0000000080000ULL 1447*08278a5eSRod Evans #define ENV_FLG_NODIRECT 0x0000000100000ULL 1448*08278a5eSRod Evans #define ENV_FLG_NOENVCONFIG 0x0000000200000ULL 1449*08278a5eSRod Evans #define ENV_FLG_NOLAZY 0x0000000400000ULL 1450*08278a5eSRod Evans #define ENV_FLG_NOOBJALTER 0x0000000800000ULL 1451*08278a5eSRod Evans #define ENV_FLG_NOVERSION 0x0000001000000ULL 1452*08278a5eSRod Evans #define ENV_FLG_PRELOAD 0x0000002000000ULL 1453*08278a5eSRod Evans #define ENV_FLG_PROFILE 0x0000004000000ULL 1454*08278a5eSRod Evans #define ENV_FLG_PROFILE_OUTPUT 0x0000008000000ULL 1455*08278a5eSRod Evans #define ENV_FLG_SIGNAL 0x0000010000000ULL 1456*08278a5eSRod Evans #define ENV_FLG_TRACE_OBJS 0x0000020000000ULL 1457*08278a5eSRod Evans #define ENV_FLG_TRACE_PTHS 0x0000040000000ULL 1458*08278a5eSRod Evans #define ENV_FLG_UNREF 0x0000080000000ULL 1459*08278a5eSRod Evans #define ENV_FLG_UNUSED 0x0000100000000ULL 1460*08278a5eSRod Evans #define ENV_FLG_VERBOSE 0x0000200000000ULL 1461*08278a5eSRod Evans #define ENV_FLG_WARN 0x0000400000000ULL 1462*08278a5eSRod Evans #define ENV_FLG_NOFLTCONFIG 0x0000800000000ULL 1463*08278a5eSRod Evans #define ENV_FLG_BIND_LAZY 0x0001000000000ULL 1464*08278a5eSRod Evans #define ENV_FLG_NOUNRESWEAK 0x0002000000000ULL 1465*08278a5eSRod Evans #define ENV_FLG_NOPAREXT 0x0004000000000ULL 1466*08278a5eSRod Evans #define ENV_FLG_HWCAP 0x0008000000000ULL 1467*08278a5eSRod Evans #define ENV_FLG_SFCAP 0x0010000000000ULL 1468*08278a5eSRod Evans #define ENV_FLG_MACHCAP 0x0020000000000ULL 1469*08278a5eSRod Evans #define ENV_FLG_PLATCAP 0x0040000000000ULL 1470*08278a5eSRod Evans #define ENV_FLG_CAP_FILES 0x0080000000000ULL 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate #define SEL_REPLACE 0x0001 14737c478bd9Sstevel@tonic-gate #define SEL_PERMANT 0x0002 14747c478bd9Sstevel@tonic-gate #define SEL_ACT_RT 0x0100 /* setting rtld_flags */ 14757c478bd9Sstevel@tonic-gate #define SEL_ACT_RT2 0x0200 /* setting rtld_flags2 */ 14767c478bd9Sstevel@tonic-gate #define SEL_ACT_STR 0x0400 /* setting string value */ 14777c478bd9Sstevel@tonic-gate #define SEL_ACT_LML 0x0800 /* setting lml_flags */ 14787c478bd9Sstevel@tonic-gate #define SEL_ACT_LMLT 0x1000 /* setting lml_tflags */ 1479635216b6SRod Evans #define SEL_ACT_SPEC_1 0x2000 /* for FLG_{FLAGS, LIBPATH} */ 14807c478bd9Sstevel@tonic-gate #define SEL_ACT_SPEC_2 0x4000 /* need special handling */ 14817c478bd9Sstevel@tonic-gate 14827c478bd9Sstevel@tonic-gate /* 14837c478bd9Sstevel@tonic-gate * Pattern match an LD_XXXX environment variable. s1 points to the XXXX part 14847c478bd9Sstevel@tonic-gate * and len specifies its length (comparing a strings length before the string 14857c478bd9Sstevel@tonic-gate * itself speed things up). s2 points to the token itself which has already 14867c478bd9Sstevel@tonic-gate * had any leading white-space removed. 14877c478bd9Sstevel@tonic-gate */ 14887c478bd9Sstevel@tonic-gate static void 14897c478bd9Sstevel@tonic-gate ld_generic_env(const char *s1, size_t len, const char *s2, Word *lmflags, 14907c478bd9Sstevel@tonic-gate Word *lmtflags, uint_t env_flags, int aout) 14917c478bd9Sstevel@tonic-gate { 14927c478bd9Sstevel@tonic-gate u_longlong_t variable = 0; 149310a4fa49Srie ushort_t select = 0; 149410a4fa49Srie const char **str; 149510a4fa49Srie Word val = 0; 14967c478bd9Sstevel@tonic-gate 14977c478bd9Sstevel@tonic-gate /* 14987c478bd9Sstevel@tonic-gate * Determine whether we're dealing with a replaceable or permanent 14997c478bd9Sstevel@tonic-gate * string. 15007c478bd9Sstevel@tonic-gate */ 15017c478bd9Sstevel@tonic-gate if (env_flags & ENV_TYP_PERMANT) { 15027c478bd9Sstevel@tonic-gate /* 15037c478bd9Sstevel@tonic-gate * If the string is from a configuration file and defined as 15047c478bd9Sstevel@tonic-gate * permanent, assign it as permanent. 15057c478bd9Sstevel@tonic-gate */ 15067c478bd9Sstevel@tonic-gate select |= SEL_PERMANT; 15077c478bd9Sstevel@tonic-gate } else 15087c478bd9Sstevel@tonic-gate select |= SEL_REPLACE; 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate /* 15117c478bd9Sstevel@tonic-gate * Parse the variable given. 15127c478bd9Sstevel@tonic-gate * 15137c478bd9Sstevel@tonic-gate * The LD_AUDIT family. 15147c478bd9Sstevel@tonic-gate */ 15157c478bd9Sstevel@tonic-gate if (*s1 == 'A') { 15167c478bd9Sstevel@tonic-gate if ((len == MSG_LD_AUDIT_SIZE) && (strncmp(s1, 15177c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_AUDIT), MSG_LD_AUDIT_SIZE) == 0)) { 15187c478bd9Sstevel@tonic-gate /* 15197c478bd9Sstevel@tonic-gate * Replaceable and permanent audit objects can exist. 15207c478bd9Sstevel@tonic-gate */ 15217c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 1522dde769a2SRod Evans str = (select & SEL_REPLACE) ? &rpl_audit : &prm_audit; 15237c478bd9Sstevel@tonic-gate variable = ENV_FLG_AUDIT; 15247c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_AUDIT_ARGS_SIZE) && 15257c478bd9Sstevel@tonic-gate (strncmp(s1, MSG_ORIG(MSG_LD_AUDIT_ARGS), 15267c478bd9Sstevel@tonic-gate MSG_LD_AUDIT_ARGS_SIZE) == 0)) { 15277c478bd9Sstevel@tonic-gate /* 15287c478bd9Sstevel@tonic-gate * A specialized variable for plt_exit() use, not 15297c478bd9Sstevel@tonic-gate * documented for general use. 15307c478bd9Sstevel@tonic-gate */ 15317c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 15327c478bd9Sstevel@tonic-gate variable = ENV_FLG_AUDIT_ARGS; 15337c478bd9Sstevel@tonic-gate } 15347c478bd9Sstevel@tonic-gate } 15357c478bd9Sstevel@tonic-gate /* 153656deab07SRod Evans * The LD_BIND family. 15377c478bd9Sstevel@tonic-gate */ 15387c478bd9Sstevel@tonic-gate else if (*s1 == 'B') { 1539dffec89cSrie if ((len == MSG_LD_BIND_LAZY_SIZE) && (strncmp(s1, 1540dffec89cSrie MSG_ORIG(MSG_LD_BIND_LAZY), 1541dffec89cSrie MSG_LD_BIND_LAZY_SIZE) == 0)) { 1542dffec89cSrie select |= SEL_ACT_RT2; 1543dffec89cSrie val = RT_FL2_BINDLAZY; 1544dffec89cSrie variable = ENV_FLG_BIND_LAZY; 1545dffec89cSrie } else if ((len == MSG_LD_BIND_NOW_SIZE) && (strncmp(s1, 15467c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_BIND_NOW), MSG_LD_BIND_NOW_SIZE) == 0)) { 15477c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT2; 15487c478bd9Sstevel@tonic-gate val = RT_FL2_BINDNOW; 15497c478bd9Sstevel@tonic-gate variable = ENV_FLG_BIND_NOW; 15507c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_BIND_NOT_SIZE) && (strncmp(s1, 15517c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_BIND_NOT), MSG_LD_BIND_NOT_SIZE) == 0)) { 15527c478bd9Sstevel@tonic-gate /* 15537c478bd9Sstevel@tonic-gate * Another trick, enabled to help debug AOUT 15547c478bd9Sstevel@tonic-gate * applications under BCP, but not documented for 15557c478bd9Sstevel@tonic-gate * general use. 15567c478bd9Sstevel@tonic-gate */ 15577c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 15587c478bd9Sstevel@tonic-gate val = RT_FL_NOBIND; 15597c478bd9Sstevel@tonic-gate variable = ENV_FLG_BIND_NOT; 15607c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_BINDINGS_SIZE) && (strncmp(s1, 15617c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_BINDINGS), MSG_LD_BINDINGS_SIZE) == 0)) { 15627c478bd9Sstevel@tonic-gate /* 15637c478bd9Sstevel@tonic-gate * This variable is simply for backward compatibility. 15647c478bd9Sstevel@tonic-gate * If this and LD_DEBUG are both specified, only one of 15657c478bd9Sstevel@tonic-gate * the strings is going to get processed. 15667c478bd9Sstevel@tonic-gate */ 15677c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 15687c478bd9Sstevel@tonic-gate variable = ENV_FLG_BINDINGS; 15697c478bd9Sstevel@tonic-gate } 15707c478bd9Sstevel@tonic-gate } 15717c478bd9Sstevel@tonic-gate /* 1572*08278a5eSRod Evans * LD_CAP_FILES and LD_CONFIG family. 15737c478bd9Sstevel@tonic-gate */ 15747c478bd9Sstevel@tonic-gate else if (*s1 == 'C') { 1575*08278a5eSRod Evans if ((len == MSG_LD_CAP_FILES_SIZE) && (strncmp(s1, 1576*08278a5eSRod Evans MSG_ORIG(MSG_LD_CAP_FILES), MSG_LD_CAP_FILES_SIZE) == 0)) { 1577*08278a5eSRod Evans select |= SEL_ACT_STR; 1578*08278a5eSRod Evans str = (select & SEL_REPLACE) ? 1579*08278a5eSRod Evans &rpl_cap_files : &prm_cap_files; 1580*08278a5eSRod Evans variable = ENV_FLG_CAP_FILES; 1581*08278a5eSRod Evans } else if ((len == MSG_LD_CONFGEN_SIZE) && (strncmp(s1, 15827c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_CONFGEN), MSG_LD_CONFGEN_SIZE) == 0)) { 15837c478bd9Sstevel@tonic-gate /* 15847c478bd9Sstevel@tonic-gate * Set by crle(1) to indicate it's building a 15857c478bd9Sstevel@tonic-gate * configuration file, not documented for general use. 15867c478bd9Sstevel@tonic-gate */ 15877c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 15887c478bd9Sstevel@tonic-gate variable = ENV_FLG_CONFGEN; 15897c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_CONFIG_SIZE) && (strncmp(s1, 15907c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_CONFIG), MSG_LD_CONFIG_SIZE) == 0)) { 15917c478bd9Sstevel@tonic-gate /* 15927c478bd9Sstevel@tonic-gate * Secure applications must use a default configuration 15937c478bd9Sstevel@tonic-gate * file. A setting from a configuration file doesn't 15947c478bd9Sstevel@tonic-gate * make sense (given we must be reading a configuration 15957c478bd9Sstevel@tonic-gate * file to have gotten this). 15967c478bd9Sstevel@tonic-gate */ 15977c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SECURE) || 15987c478bd9Sstevel@tonic-gate (env_flags & ENV_TYP_CONFIG)) 15997c478bd9Sstevel@tonic-gate return; 16007c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 16017c478bd9Sstevel@tonic-gate str = &config->c_name; 16027c478bd9Sstevel@tonic-gate variable = ENV_FLG_CONFIG; 16037c478bd9Sstevel@tonic-gate } 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate /* 16067c478bd9Sstevel@tonic-gate * The LD_DEBUG family and LD_DEMANGLE. 16077c478bd9Sstevel@tonic-gate */ 16087c478bd9Sstevel@tonic-gate else if (*s1 == 'D') { 16097c478bd9Sstevel@tonic-gate if ((len == MSG_LD_DEBUG_SIZE) && (strncmp(s1, 16107c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_DEBUG), MSG_LD_DEBUG_SIZE) == 0)) { 16117c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 1612dde769a2SRod Evans str = (select & SEL_REPLACE) ? &rpl_debug : &prm_debug; 16137c478bd9Sstevel@tonic-gate variable = ENV_FLG_DEBUG; 16147c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_DEBUG_OUTPUT_SIZE) && (strncmp(s1, 16157c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_DEBUG_OUTPUT), 16167c478bd9Sstevel@tonic-gate MSG_LD_DEBUG_OUTPUT_SIZE) == 0)) { 16177c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 16187c478bd9Sstevel@tonic-gate str = &dbg_file; 16197c478bd9Sstevel@tonic-gate variable = ENV_FLG_DEBUG_OUTPUT; 16207c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_DEMANGLE_SIZE) && (strncmp(s1, 16217c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_DEMANGLE), MSG_LD_DEMANGLE_SIZE) == 0)) { 16227c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 16237c478bd9Sstevel@tonic-gate val = RT_FL_DEMANGLE; 16247c478bd9Sstevel@tonic-gate variable = ENV_FLG_DEMANGLE; 16257c478bd9Sstevel@tonic-gate } 16267c478bd9Sstevel@tonic-gate } 16277c478bd9Sstevel@tonic-gate /* 16287c478bd9Sstevel@tonic-gate * LD_FLAGS - collect the best variable definition. On completion of 16297c478bd9Sstevel@tonic-gate * environment variable processing pass the result to ld_flags_env() 16307c478bd9Sstevel@tonic-gate * where they'll be decomposed and passed back to this routine. 16317c478bd9Sstevel@tonic-gate */ 16327c478bd9Sstevel@tonic-gate else if (*s1 == 'F') { 16337c478bd9Sstevel@tonic-gate if ((len == MSG_LD_FLAGS_SIZE) && (strncmp(s1, 16347c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_FLAGS), MSG_LD_FLAGS_SIZE) == 0)) { 16357c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_1; 1636dde769a2SRod Evans str = (select & SEL_REPLACE) ? &rpl_ldflags : 1637dde769a2SRod Evans &prm_ldflags; 16387c478bd9Sstevel@tonic-gate variable = ENV_FLG_FLAGS; 16397c478bd9Sstevel@tonic-gate } 16407c478bd9Sstevel@tonic-gate } 1641*08278a5eSRod Evans /* 1642*08278a5eSRod Evans * LD_HWCAP. 1643*08278a5eSRod Evans */ 1644*08278a5eSRod Evans else if (*s1 == 'H') { 1645*08278a5eSRod Evans if ((len == MSG_LD_HWCAP_SIZE) && (strncmp(s1, 1646*08278a5eSRod Evans MSG_ORIG(MSG_LD_HWCAP), MSG_LD_HWCAP_SIZE) == 0)) { 1647*08278a5eSRod Evans select |= SEL_ACT_STR; 1648*08278a5eSRod Evans str = (select & SEL_REPLACE) ? 1649*08278a5eSRod Evans &rpl_hwcap : &prm_hwcap; 1650*08278a5eSRod Evans variable = ENV_FLG_HWCAP; 1651*08278a5eSRod Evans } 1652*08278a5eSRod Evans } 16537c478bd9Sstevel@tonic-gate /* 16547c478bd9Sstevel@tonic-gate * LD_INIT (internal, used by ldd(1)). 16557c478bd9Sstevel@tonic-gate */ 16567c478bd9Sstevel@tonic-gate else if (*s1 == 'I') { 16577c478bd9Sstevel@tonic-gate if ((len == MSG_LD_INIT_SIZE) && (strncmp(s1, 16587c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_INIT), MSG_LD_INIT_SIZE) == 0)) { 16597c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 16607c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_INIT; 16617c478bd9Sstevel@tonic-gate variable = ENV_FLG_INIT; 16627c478bd9Sstevel@tonic-gate } 16637c478bd9Sstevel@tonic-gate } 16647c478bd9Sstevel@tonic-gate /* 16657c478bd9Sstevel@tonic-gate * The LD_LIBRARY_PATH and LD_LOAD families. 16667c478bd9Sstevel@tonic-gate */ 16677c478bd9Sstevel@tonic-gate else if (*s1 == 'L') { 16687c478bd9Sstevel@tonic-gate if ((len == MSG_LD_LIBPATH_SIZE) && (strncmp(s1, 16697c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_LIBPATH), MSG_LD_LIBPATH_SIZE) == 0)) { 16707c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_1; 1671dde769a2SRod Evans str = (select & SEL_REPLACE) ? &rpl_libpath : 1672dde769a2SRod Evans &prm_libpath; 16737c478bd9Sstevel@tonic-gate variable = ENV_FLG_LIBPATH; 16747c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_LOADAVAIL_SIZE) && (strncmp(s1, 16757c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_LOADAVAIL), MSG_LD_LOADAVAIL_SIZE) == 0)) { 16767c478bd9Sstevel@tonic-gate /* 16777c478bd9Sstevel@tonic-gate * Internal use by crle(1), not documented for general 16787c478bd9Sstevel@tonic-gate * use. 16797c478bd9Sstevel@tonic-gate */ 16807c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 16817c478bd9Sstevel@tonic-gate val = LML_FLG_LOADAVAIL; 16827c478bd9Sstevel@tonic-gate variable = ENV_FLG_LOADAVAIL; 16837c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_LOADFLTR_SIZE) && (strncmp(s1, 16847c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_LOADFLTR), MSG_LD_LOADFLTR_SIZE) == 0)) { 16857c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 16867c478bd9Sstevel@tonic-gate variable = ENV_FLG_LOADFLTR; 16877c478bd9Sstevel@tonic-gate } 16887c478bd9Sstevel@tonic-gate } 1689*08278a5eSRod Evans /* 1690*08278a5eSRod Evans * LD_MACHCAP. 1691*08278a5eSRod Evans */ 1692*08278a5eSRod Evans else if (*s1 == 'M') { 1693*08278a5eSRod Evans if ((len == MSG_LD_MACHCAP_SIZE) && (strncmp(s1, 1694*08278a5eSRod Evans MSG_ORIG(MSG_LD_MACHCAP), MSG_LD_MACHCAP_SIZE) == 0)) { 1695*08278a5eSRod Evans select |= SEL_ACT_STR; 1696*08278a5eSRod Evans str = (select & SEL_REPLACE) ? 1697*08278a5eSRod Evans &rpl_machcap : &prm_machcap; 1698*08278a5eSRod Evans variable = ENV_FLG_MACHCAP; 1699*08278a5eSRod Evans } 1700*08278a5eSRod Evans } 17017c478bd9Sstevel@tonic-gate /* 17027c478bd9Sstevel@tonic-gate * The LD_NO family. 17037c478bd9Sstevel@tonic-gate */ 17047c478bd9Sstevel@tonic-gate else if (*s1 == 'N') { 17057c478bd9Sstevel@tonic-gate if ((len == MSG_LD_NOAUDIT_SIZE) && (strncmp(s1, 17067c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOAUDIT), MSG_LD_NOAUDIT_SIZE) == 0)) { 17077c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17087c478bd9Sstevel@tonic-gate val = RT_FL_NOAUDIT; 17097c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOAUDIT; 17107c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOAUXFLTR_SIZE) && (strncmp(s1, 17117c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOAUXFLTR), MSG_LD_NOAUXFLTR_SIZE) == 0)) { 17127c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17137c478bd9Sstevel@tonic-gate val = RT_FL_NOAUXFLTR; 17147c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOAUXFLTR; 17157c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOBAPLT_SIZE) && (strncmp(s1, 17167c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOBAPLT), MSG_LD_NOBAPLT_SIZE) == 0)) { 17177c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17187c478bd9Sstevel@tonic-gate val = RT_FL_NOBAPLT; 17197c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOBAPLT; 17207c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOCONFIG_SIZE) && (strncmp(s1, 17217c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOCONFIG), MSG_LD_NOCONFIG_SIZE) == 0)) { 17227c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17237c478bd9Sstevel@tonic-gate val = RT_FL_NOCFG; 17247c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOCONFIG; 17257c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NODIRCONFIG_SIZE) && (strncmp(s1, 17267c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NODIRCONFIG), 17277c478bd9Sstevel@tonic-gate MSG_LD_NODIRCONFIG_SIZE) == 0)) { 17287c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17297c478bd9Sstevel@tonic-gate val = RT_FL_NODIRCFG; 17307c478bd9Sstevel@tonic-gate variable = ENV_FLG_NODIRCONFIG; 17317c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NODIRECT_SIZE) && (strncmp(s1, 17327c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NODIRECT), MSG_LD_NODIRECT_SIZE) == 0)) { 17337c478bd9Sstevel@tonic-gate select |= SEL_ACT_LMLT; 17347c478bd9Sstevel@tonic-gate val = LML_TFLG_NODIRECT; 17357c478bd9Sstevel@tonic-gate variable = ENV_FLG_NODIRECT; 17367c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOENVCONFIG_SIZE) && (strncmp(s1, 17377c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOENVCONFIG), 17387c478bd9Sstevel@tonic-gate MSG_LD_NOENVCONFIG_SIZE) == 0)) { 17397c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17407c478bd9Sstevel@tonic-gate val = RT_FL_NOENVCFG; 17417c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOENVCONFIG; 17427c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOFLTCONFIG_SIZE) && (strncmp(s1, 17437c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOFLTCONFIG), 17447c478bd9Sstevel@tonic-gate MSG_LD_NOFLTCONFIG_SIZE) == 0)) { 17457c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT2; 17467c478bd9Sstevel@tonic-gate val = RT_FL2_NOFLTCFG; 17477c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOFLTCONFIG; 17487c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOLAZY_SIZE) && (strncmp(s1, 17497c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOLAZY), MSG_LD_NOLAZY_SIZE) == 0)) { 17507c478bd9Sstevel@tonic-gate select |= SEL_ACT_LMLT; 17517c478bd9Sstevel@tonic-gate val = LML_TFLG_NOLAZYLD; 17527c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOLAZY; 17537c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOOBJALTER_SIZE) && (strncmp(s1, 17547c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOOBJALTER), 17557c478bd9Sstevel@tonic-gate MSG_LD_NOOBJALTER_SIZE) == 0)) { 17567c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17577c478bd9Sstevel@tonic-gate val = RT_FL_NOOBJALT; 17587c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOOBJALTER; 17597c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_NOVERSION_SIZE) && (strncmp(s1, 17607c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_NOVERSION), MSG_LD_NOVERSION_SIZE) == 0)) { 17617c478bd9Sstevel@tonic-gate select |= SEL_ACT_RT; 17627c478bd9Sstevel@tonic-gate val = RT_FL_NOVERSION; 17637c478bd9Sstevel@tonic-gate variable = ENV_FLG_NOVERSION; 1764df4628cbSrie } else if ((len == MSG_LD_NOUNRESWEAK_SIZE) && (strncmp(s1, 1765df4628cbSrie MSG_ORIG(MSG_LD_NOUNRESWEAK), 1766df4628cbSrie MSG_LD_NOUNRESWEAK_SIZE) == 0)) { 1767df4628cbSrie /* 1768df4628cbSrie * LD_NOUNRESWEAK (internal, used by ldd(1)). 1769df4628cbSrie */ 1770df4628cbSrie select |= SEL_ACT_LML; 1771df4628cbSrie val = LML_FLG_TRC_NOUNRESWEAK; 1772df4628cbSrie variable = ENV_FLG_NOUNRESWEAK; 1773dae2dfb7Srie } else if ((len == MSG_LD_NOPAREXT_SIZE) && (strncmp(s1, 1774dae2dfb7Srie MSG_ORIG(MSG_LD_NOPAREXT), MSG_LD_NOPAREXT_SIZE) == 0)) { 1775dae2dfb7Srie select |= SEL_ACT_LML; 1776dae2dfb7Srie val = LML_FLG_TRC_NOPAREXT; 1777dae2dfb7Srie variable = ENV_FLG_NOPAREXT; 17787c478bd9Sstevel@tonic-gate } 17797c478bd9Sstevel@tonic-gate } 17807c478bd9Sstevel@tonic-gate /* 1781*08278a5eSRod Evans * LD_PLATCAP, LD_PRELOAD and LD_PROFILE family. 17827c478bd9Sstevel@tonic-gate */ 17837c478bd9Sstevel@tonic-gate else if (*s1 == 'P') { 1784*08278a5eSRod Evans if ((len == MSG_LD_PLATCAP_SIZE) && (strncmp(s1, 1785*08278a5eSRod Evans MSG_ORIG(MSG_LD_PLATCAP), MSG_LD_PLATCAP_SIZE) == 0)) { 1786*08278a5eSRod Evans select |= SEL_ACT_STR; 1787*08278a5eSRod Evans str = (select & SEL_REPLACE) ? 1788*08278a5eSRod Evans &rpl_platcap : &prm_platcap; 1789*08278a5eSRod Evans variable = ENV_FLG_PLATCAP; 1790*08278a5eSRod Evans } else if ((len == MSG_LD_PRELOAD_SIZE) && (strncmp(s1, 17917c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_PRELOAD), MSG_LD_PRELOAD_SIZE) == 0)) { 17927c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 1793dde769a2SRod Evans str = (select & SEL_REPLACE) ? &rpl_preload : 1794dde769a2SRod Evans &prm_preload; 17957c478bd9Sstevel@tonic-gate variable = ENV_FLG_PRELOAD; 17967c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_PROFILE_SIZE) && (strncmp(s1, 17977c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_PROFILE), MSG_LD_PROFILE_SIZE) == 0)) { 17987c478bd9Sstevel@tonic-gate /* 17997c478bd9Sstevel@tonic-gate * Only one user library can be profiled at a time. 18007c478bd9Sstevel@tonic-gate */ 18017c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 18027c478bd9Sstevel@tonic-gate variable = ENV_FLG_PROFILE; 18037c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_PROFILE_OUTPUT_SIZE) && (strncmp(s1, 18047c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_PROFILE_OUTPUT), 18057c478bd9Sstevel@tonic-gate MSG_LD_PROFILE_OUTPUT_SIZE) == 0)) { 18067c478bd9Sstevel@tonic-gate /* 18077c478bd9Sstevel@tonic-gate * Only one user library can be profiled at a time. 18087c478bd9Sstevel@tonic-gate */ 18097c478bd9Sstevel@tonic-gate select |= SEL_ACT_STR; 18107c478bd9Sstevel@tonic-gate str = &profile_out; 18117c478bd9Sstevel@tonic-gate variable = ENV_FLG_PROFILE_OUTPUT; 18127c478bd9Sstevel@tonic-gate } 18137c478bd9Sstevel@tonic-gate } 18147c478bd9Sstevel@tonic-gate /* 1815*08278a5eSRod Evans * LD_SFCAP and LD_SIGNAL. 18167c478bd9Sstevel@tonic-gate */ 18177c478bd9Sstevel@tonic-gate else if (*s1 == 'S') { 1818*08278a5eSRod Evans if ((len == MSG_LD_SFCAP_SIZE) && (strncmp(s1, 1819*08278a5eSRod Evans MSG_ORIG(MSG_LD_SFCAP), MSG_LD_SFCAP_SIZE) == 0)) { 1820*08278a5eSRod Evans select |= SEL_ACT_STR; 1821*08278a5eSRod Evans str = (select & SEL_REPLACE) ? 1822*08278a5eSRod Evans &rpl_sfcap : &prm_sfcap; 1823*08278a5eSRod Evans variable = ENV_FLG_SFCAP; 1824*08278a5eSRod Evans } else if ((len == MSG_LD_SIGNAL_SIZE) && 18257c478bd9Sstevel@tonic-gate (strncmp(s1, MSG_ORIG(MSG_LD_SIGNAL), 1826*08278a5eSRod Evans MSG_LD_SIGNAL_SIZE) == 0) && 1827*08278a5eSRod Evans ((rtld_flags & RT_FL_SECURE) == 0)) { 18287c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 18297c478bd9Sstevel@tonic-gate variable = ENV_FLG_SIGNAL; 18307c478bd9Sstevel@tonic-gate } 18317c478bd9Sstevel@tonic-gate } 18327c478bd9Sstevel@tonic-gate /* 18331d1fba8aSrie * The LD_TRACE family (internal, used by ldd(1)). This definition is 18341d1fba8aSrie * the key to enabling all other ldd(1) specific environment variables. 18351d1fba8aSrie * In case an auditor is called, which in turn might exec(2) a 18361d1fba8aSrie * subprocess, this variable is disabled, so that any subprocess 18371d1fba8aSrie * escapes ldd(1) processing. 18387c478bd9Sstevel@tonic-gate */ 18397c478bd9Sstevel@tonic-gate else if (*s1 == 'T') { 18407c478bd9Sstevel@tonic-gate if (((len == MSG_LD_TRACE_OBJS_SIZE) && 18417c478bd9Sstevel@tonic-gate (strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS), 18427c478bd9Sstevel@tonic-gate MSG_LD_TRACE_OBJS_SIZE) == 0)) || 18437c478bd9Sstevel@tonic-gate ((len == MSG_LD_TRACE_OBJS_E_SIZE) && 18447c478bd9Sstevel@tonic-gate (((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_E), 18457c478bd9Sstevel@tonic-gate MSG_LD_TRACE_OBJS_E_SIZE) == 0) && !aout) || 18467c478bd9Sstevel@tonic-gate ((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_A), 18477c478bd9Sstevel@tonic-gate MSG_LD_TRACE_OBJS_A_SIZE) == 0) && aout)))) { 18481d1fba8aSrie char *s0 = (char *)s1; 18491d1fba8aSrie 18507c478bd9Sstevel@tonic-gate select |= SEL_ACT_SPEC_2; 18517c478bd9Sstevel@tonic-gate variable = ENV_FLG_TRACE_OBJS; 18521d1fba8aSrie 185302ca3e02Srie #if defined(__sparc) || defined(__x86) 18541d1fba8aSrie /* 18551d1fba8aSrie * The simplest way to "disable" this variable is to 18561d1fba8aSrie * truncate this string to "LD_'\0'". This string is 18571d1fba8aSrie * ignored by any ld.so.1 environment processing. 18581d1fba8aSrie * Use of such interfaces as unsetenv(3c) are overkill, 18591d1fba8aSrie * and would drag too much libc implementation detail 18601d1fba8aSrie * into ld.so.1. 18611d1fba8aSrie */ 1862a953e2b1Srie *s0 = '\0'; 18631d1fba8aSrie #else 18641d1fba8aSrie /* 18651d1fba8aSrie * Verify that the above write is appropriate for any new platforms. 18661d1fba8aSrie */ 18671d1fba8aSrie #error unsupported architecture! 18681d1fba8aSrie #endif 18697c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_TRACE_PTHS_SIZE) && (strncmp(s1, 18707c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_TRACE_PTHS), 18717c478bd9Sstevel@tonic-gate MSG_LD_TRACE_PTHS_SIZE) == 0)) { 18727c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 18737c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_SEARCH; 18747c478bd9Sstevel@tonic-gate variable = ENV_FLG_TRACE_PTHS; 18757c478bd9Sstevel@tonic-gate } 18767c478bd9Sstevel@tonic-gate } 18777c478bd9Sstevel@tonic-gate /* 18787c478bd9Sstevel@tonic-gate * LD_UNREF and LD_UNUSED (internal, used by ldd(1)). 18797c478bd9Sstevel@tonic-gate */ 18807c478bd9Sstevel@tonic-gate else if (*s1 == 'U') { 18817c478bd9Sstevel@tonic-gate if ((len == MSG_LD_UNREF_SIZE) && (strncmp(s1, 18827c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_UNREF), MSG_LD_UNREF_SIZE) == 0)) { 18837c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 18847c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_UNREF; 18857c478bd9Sstevel@tonic-gate variable = ENV_FLG_UNREF; 18867c478bd9Sstevel@tonic-gate } else if ((len == MSG_LD_UNUSED_SIZE) && (strncmp(s1, 18877c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_UNUSED), MSG_LD_UNUSED_SIZE) == 0)) { 18887c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 18897c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_UNUSED; 18907c478bd9Sstevel@tonic-gate variable = ENV_FLG_UNUSED; 18917c478bd9Sstevel@tonic-gate } 18927c478bd9Sstevel@tonic-gate } 18937c478bd9Sstevel@tonic-gate /* 18947c478bd9Sstevel@tonic-gate * LD_VERBOSE (internal, used by ldd(1)). 18957c478bd9Sstevel@tonic-gate */ 18967c478bd9Sstevel@tonic-gate else if (*s1 == 'V') { 18977c478bd9Sstevel@tonic-gate if ((len == MSG_LD_VERBOSE_SIZE) && (strncmp(s1, 18987c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_VERBOSE), MSG_LD_VERBOSE_SIZE) == 0)) { 18997c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 19007c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_VERBOSE; 19017c478bd9Sstevel@tonic-gate variable = ENV_FLG_VERBOSE; 19027c478bd9Sstevel@tonic-gate } 19037c478bd9Sstevel@tonic-gate } 19047c478bd9Sstevel@tonic-gate /* 19057c478bd9Sstevel@tonic-gate * LD_WARN (internal, used by ldd(1)). 19067c478bd9Sstevel@tonic-gate */ 19077c478bd9Sstevel@tonic-gate else if (*s1 == 'W') { 19087c478bd9Sstevel@tonic-gate if ((len == MSG_LD_WARN_SIZE) && (strncmp(s1, 19097c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_LD_WARN), MSG_LD_WARN_SIZE) == 0)) { 19107c478bd9Sstevel@tonic-gate select |= SEL_ACT_LML; 19117c478bd9Sstevel@tonic-gate val = LML_FLG_TRC_WARN; 19127c478bd9Sstevel@tonic-gate variable = ENV_FLG_WARN; 19137c478bd9Sstevel@tonic-gate } 19147c478bd9Sstevel@tonic-gate } 191556deab07SRod Evans 19167c478bd9Sstevel@tonic-gate if (variable == 0) 19177c478bd9Sstevel@tonic-gate return; 19187c478bd9Sstevel@tonic-gate 19197c478bd9Sstevel@tonic-gate /* 1920635216b6SRod Evans * If the variable is already processed with and ISA specific variable, 1921635216b6SRod Evans * no further processing is needed. 19227c478bd9Sstevel@tonic-gate */ 19237c478bd9Sstevel@tonic-gate if (((select & SEL_REPLACE) && (rplisa & variable)) || 19247c478bd9Sstevel@tonic-gate ((select & SEL_PERMANT) && (prmisa & variable))) 19257c478bd9Sstevel@tonic-gate return; 19267c478bd9Sstevel@tonic-gate 19277c478bd9Sstevel@tonic-gate /* 1928635216b6SRod Evans * Mark the appropriate variables. 19297c478bd9Sstevel@tonic-gate */ 19307c478bd9Sstevel@tonic-gate if (env_flags & ENV_TYP_ISA) { 19317c478bd9Sstevel@tonic-gate /* 1932635216b6SRod Evans * This is an ISA setting. 19337c478bd9Sstevel@tonic-gate */ 19347c478bd9Sstevel@tonic-gate if (select & SEL_REPLACE) { 1935fa034d7fSseizo if (rplisa & variable) 1936fa034d7fSseizo return; 19377c478bd9Sstevel@tonic-gate rplisa |= variable; 19387c478bd9Sstevel@tonic-gate } else { 19397c478bd9Sstevel@tonic-gate prmisa |= variable; 19407c478bd9Sstevel@tonic-gate } 1941635216b6SRod Evans } else { 19427c478bd9Sstevel@tonic-gate /* 1943dde769a2SRod Evans * This is a non-ISA setting. 19447c478bd9Sstevel@tonic-gate */ 19457c478bd9Sstevel@tonic-gate if (select & SEL_REPLACE) { 1946fa034d7fSseizo if (rplgen & variable) 1947fa034d7fSseizo return; 19487c478bd9Sstevel@tonic-gate rplgen |= variable; 19497c478bd9Sstevel@tonic-gate } else 19507c478bd9Sstevel@tonic-gate prmgen |= variable; 1951635216b6SRod Evans } 19527c478bd9Sstevel@tonic-gate 19537c478bd9Sstevel@tonic-gate /* 19547c478bd9Sstevel@tonic-gate * Now perform the setting. 19557c478bd9Sstevel@tonic-gate */ 19567c478bd9Sstevel@tonic-gate if (select & SEL_ACT_RT) { 19577c478bd9Sstevel@tonic-gate if (s2) 19587c478bd9Sstevel@tonic-gate rtld_flags |= val; 19597c478bd9Sstevel@tonic-gate else 19607c478bd9Sstevel@tonic-gate rtld_flags &= ~val; 19617c478bd9Sstevel@tonic-gate } else if (select & SEL_ACT_RT2) { 19627c478bd9Sstevel@tonic-gate if (s2) 19637c478bd9Sstevel@tonic-gate rtld_flags2 |= val; 19647c478bd9Sstevel@tonic-gate else 19657c478bd9Sstevel@tonic-gate rtld_flags2 &= ~val; 1966635216b6SRod Evans } else if (select & SEL_ACT_STR) { 19677c478bd9Sstevel@tonic-gate *str = s2; 1968635216b6SRod Evans } else if (select & SEL_ACT_LML) { 19697c478bd9Sstevel@tonic-gate if (s2) 19707c478bd9Sstevel@tonic-gate *lmflags |= val; 19717c478bd9Sstevel@tonic-gate else 19727c478bd9Sstevel@tonic-gate *lmflags &= ~val; 19737c478bd9Sstevel@tonic-gate } else if (select & SEL_ACT_LMLT) { 19747c478bd9Sstevel@tonic-gate if (s2) 19757c478bd9Sstevel@tonic-gate *lmtflags |= val; 19767c478bd9Sstevel@tonic-gate else 19777c478bd9Sstevel@tonic-gate *lmtflags &= ~val; 19787c478bd9Sstevel@tonic-gate } else if (select & SEL_ACT_SPEC_1) { 19797c478bd9Sstevel@tonic-gate /* 19807c478bd9Sstevel@tonic-gate * variable is either ENV_FLG_FLAGS or ENV_FLG_LIBPATH 19817c478bd9Sstevel@tonic-gate */ 19827c478bd9Sstevel@tonic-gate *str = s2; 19837c478bd9Sstevel@tonic-gate if ((select & SEL_REPLACE) && (env_flags & ENV_TYP_CONFIG)) { 19847c478bd9Sstevel@tonic-gate if (s2) { 19857c478bd9Sstevel@tonic-gate if (variable == ENV_FLG_FLAGS) 19867c478bd9Sstevel@tonic-gate env_info |= ENV_INF_FLAGCFG; 19877c478bd9Sstevel@tonic-gate else 19887c478bd9Sstevel@tonic-gate env_info |= ENV_INF_PATHCFG; 19897c478bd9Sstevel@tonic-gate } else { 19907c478bd9Sstevel@tonic-gate if (variable == ENV_FLG_FLAGS) 19917c478bd9Sstevel@tonic-gate env_info &= ~ENV_INF_FLAGCFG; 19927c478bd9Sstevel@tonic-gate else 19937c478bd9Sstevel@tonic-gate env_info &= ~ENV_INF_PATHCFG; 19947c478bd9Sstevel@tonic-gate } 19957c478bd9Sstevel@tonic-gate } 19967c478bd9Sstevel@tonic-gate } else if (select & SEL_ACT_SPEC_2) { 19977c478bd9Sstevel@tonic-gate /* 19987c478bd9Sstevel@tonic-gate * variables can be: ENV_FLG_ 1999635216b6SRod Evans * AUDIT_ARGS, BINDING, CONFGEN, LOADFLTR, PROFILE, 2000635216b6SRod Evans * SIGNAL, TRACE_OBJS 20017c478bd9Sstevel@tonic-gate */ 2002635216b6SRod Evans switch (variable) { 2003635216b6SRod Evans case ENV_FLG_AUDIT_ARGS: 20047c478bd9Sstevel@tonic-gate if (s2) { 20057c478bd9Sstevel@tonic-gate audit_argcnt = atoi(s2); 20067c478bd9Sstevel@tonic-gate audit_argcnt += audit_argcnt % 2; 20077c478bd9Sstevel@tonic-gate } else 20087c478bd9Sstevel@tonic-gate audit_argcnt = 0; 2009635216b6SRod Evans break; 2010635216b6SRod Evans case ENV_FLG_BINDINGS: 20117c478bd9Sstevel@tonic-gate if (s2) 20127c478bd9Sstevel@tonic-gate rpl_debug = MSG_ORIG(MSG_TKN_BINDINGS); 20137c478bd9Sstevel@tonic-gate else 201443d7826aSRod Evans rpl_debug = NULL; 2015635216b6SRod Evans break; 2016635216b6SRod Evans case ENV_FLG_CONFGEN: 20177c478bd9Sstevel@tonic-gate if (s2) { 20187c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_CONFGEN; 20197c478bd9Sstevel@tonic-gate *lmflags |= LML_FLG_IGNRELERR; 20207c478bd9Sstevel@tonic-gate } else { 20217c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_CONFGEN; 20227c478bd9Sstevel@tonic-gate *lmflags &= ~LML_FLG_IGNRELERR; 20237c478bd9Sstevel@tonic-gate } 2024635216b6SRod Evans break; 2025635216b6SRod Evans case ENV_FLG_LOADFLTR: 20267c478bd9Sstevel@tonic-gate if (s2) { 20277c478bd9Sstevel@tonic-gate *lmtflags |= LML_TFLG_LOADFLTR; 20287c478bd9Sstevel@tonic-gate if (*s2 == '2') 20297c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_WARNFLTR; 20307c478bd9Sstevel@tonic-gate } else { 20317c478bd9Sstevel@tonic-gate *lmtflags &= ~LML_TFLG_LOADFLTR; 20327c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_WARNFLTR; 20337c478bd9Sstevel@tonic-gate } 2034635216b6SRod Evans break; 2035635216b6SRod Evans case ENV_FLG_PROFILE: 20367c478bd9Sstevel@tonic-gate profile_name = s2; 20377c478bd9Sstevel@tonic-gate if (s2) { 20387c478bd9Sstevel@tonic-gate if (strcmp(s2, MSG_ORIG(MSG_FIL_RTLD)) == 0) { 20397c478bd9Sstevel@tonic-gate return; 20407c478bd9Sstevel@tonic-gate } 2041a953e2b1Srie /* BEGIN CSTYLED */ 20427c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_SECURE) { 20437c478bd9Sstevel@tonic-gate profile_lib = 20447c478bd9Sstevel@tonic-gate #if defined(_ELF64) 20457c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_LDPROFSE_64); 20467c478bd9Sstevel@tonic-gate #else 20477c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_LDPROFSE); 20487c478bd9Sstevel@tonic-gate #endif 20497c478bd9Sstevel@tonic-gate } else { 20507c478bd9Sstevel@tonic-gate profile_lib = 20517c478bd9Sstevel@tonic-gate #if defined(_ELF64) 20527c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_LDPROF_64); 20537c478bd9Sstevel@tonic-gate #else 20547c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_LDPROF); 20557c478bd9Sstevel@tonic-gate #endif 20567c478bd9Sstevel@tonic-gate } 2057a953e2b1Srie /* END CSTYLED */ 20587c478bd9Sstevel@tonic-gate } else 205956deab07SRod Evans profile_lib = NULL; 2060635216b6SRod Evans break; 2061635216b6SRod Evans case ENV_FLG_SIGNAL: 20627c478bd9Sstevel@tonic-gate killsig = s2 ? atoi(s2) : SIGKILL; 2063635216b6SRod Evans break; 2064635216b6SRod Evans case ENV_FLG_TRACE_OBJS: 20657c478bd9Sstevel@tonic-gate if (s2) { 20667c478bd9Sstevel@tonic-gate *lmflags |= LML_FLG_TRC_ENABLE; 20677c478bd9Sstevel@tonic-gate if (*s2 == '2') 20687c478bd9Sstevel@tonic-gate *lmflags |= LML_FLG_TRC_LDDSTUB; 20697c478bd9Sstevel@tonic-gate } else 20707c478bd9Sstevel@tonic-gate *lmflags &= 2071dde769a2SRod Evans ~(LML_FLG_TRC_ENABLE | LML_FLG_TRC_LDDSTUB); 2072635216b6SRod Evans break; 20737c478bd9Sstevel@tonic-gate } 20747c478bd9Sstevel@tonic-gate } 20757c478bd9Sstevel@tonic-gate } 20767c478bd9Sstevel@tonic-gate 20777c478bd9Sstevel@tonic-gate /* 20787c478bd9Sstevel@tonic-gate * Determine whether we have an architecture specific environment variable. 20797c478bd9Sstevel@tonic-gate * If we do, and we're the wrong architecture, it'll just get ignored. 20807c478bd9Sstevel@tonic-gate * Otherwise the variable is processed in it's architecture neutral form. 20817c478bd9Sstevel@tonic-gate */ 20827c478bd9Sstevel@tonic-gate static int 20837c478bd9Sstevel@tonic-gate ld_arch_env(const char *s1, size_t *len) 20847c478bd9Sstevel@tonic-gate { 20857c478bd9Sstevel@tonic-gate size_t _len = *len - 3; 20867c478bd9Sstevel@tonic-gate 20877c478bd9Sstevel@tonic-gate if (s1[_len++] == '_') { 20887c478bd9Sstevel@tonic-gate if ((s1[_len] == '3') && (s1[_len + 1] == '2')) { 20897c478bd9Sstevel@tonic-gate #if defined(_ELF64) 20907c478bd9Sstevel@tonic-gate return (ENV_TYP_IGNORE); 20917c478bd9Sstevel@tonic-gate #else 20927c478bd9Sstevel@tonic-gate *len = *len - 3; 20937c478bd9Sstevel@tonic-gate return (ENV_TYP_ISA); 20947c478bd9Sstevel@tonic-gate #endif 20957c478bd9Sstevel@tonic-gate } 20967c478bd9Sstevel@tonic-gate if ((s1[_len] == '6') && (s1[_len + 1] == '4')) { 20977c478bd9Sstevel@tonic-gate #if defined(_ELF64) 20987c478bd9Sstevel@tonic-gate *len = *len - 3; 20997c478bd9Sstevel@tonic-gate return (ENV_TYP_ISA); 21007c478bd9Sstevel@tonic-gate #else 21017c478bd9Sstevel@tonic-gate return (ENV_TYP_IGNORE); 21027c478bd9Sstevel@tonic-gate #endif 21037c478bd9Sstevel@tonic-gate } 21047c478bd9Sstevel@tonic-gate } 21057c478bd9Sstevel@tonic-gate return (0); 21067c478bd9Sstevel@tonic-gate } 21077c478bd9Sstevel@tonic-gate 21087c478bd9Sstevel@tonic-gate 21097c478bd9Sstevel@tonic-gate /* 21107c478bd9Sstevel@tonic-gate * Process an LD_FLAGS environment variable. The value can be a comma 21117c478bd9Sstevel@tonic-gate * separated set of tokens, which are sent (in upper case) into the generic 21127c478bd9Sstevel@tonic-gate * LD_XXXX environment variable engine. For example: 21137c478bd9Sstevel@tonic-gate * 21147c478bd9Sstevel@tonic-gate * LD_FLAGS=bind_now -> LD_BIND_NOW=1 21157c478bd9Sstevel@tonic-gate * LD_FLAGS=library_path=/foo:. -> LD_LIBRARY_PATH=/foo:. 21167c478bd9Sstevel@tonic-gate * LD_FLAGS=debug=files:detail -> LD_DEBUG=files:detail 21177c478bd9Sstevel@tonic-gate * or 21187c478bd9Sstevel@tonic-gate * LD_FLAGS=bind_now,library_path=/foo:.,debug=files:detail 21197c478bd9Sstevel@tonic-gate */ 21207c478bd9Sstevel@tonic-gate static int 21217c478bd9Sstevel@tonic-gate ld_flags_env(const char *str, Word *lmflags, Word *lmtflags, 21227c478bd9Sstevel@tonic-gate uint_t env_flags, int aout) 21237c478bd9Sstevel@tonic-gate { 21243dbfc803SRod Evans char *nstr, *sstr, *estr = NULL; 21257c478bd9Sstevel@tonic-gate size_t nlen, len; 21267c478bd9Sstevel@tonic-gate 21273dbfc803SRod Evans if (str == NULL) 21287c478bd9Sstevel@tonic-gate return (0); 21297c478bd9Sstevel@tonic-gate 21307c478bd9Sstevel@tonic-gate /* 21317c478bd9Sstevel@tonic-gate * Create a new string as we're going to transform the token(s) into 21327c478bd9Sstevel@tonic-gate * uppercase and separate tokens with nulls. 21337c478bd9Sstevel@tonic-gate */ 21347c478bd9Sstevel@tonic-gate len = strlen(str); 21353dbfc803SRod Evans if ((nstr = malloc(len + 1)) == NULL) 21367c478bd9Sstevel@tonic-gate return (1); 21377c478bd9Sstevel@tonic-gate (void) strcpy(nstr, str); 21387c478bd9Sstevel@tonic-gate 21397c478bd9Sstevel@tonic-gate for (sstr = nstr; sstr; sstr++, len--) { 21407c478bd9Sstevel@tonic-gate int flags; 21417c478bd9Sstevel@tonic-gate 21427c478bd9Sstevel@tonic-gate if ((*sstr != '\0') && (*sstr != ',')) { 21433dbfc803SRod Evans if (estr == NULL) { 21447c478bd9Sstevel@tonic-gate if (*sstr == '=') 21457c478bd9Sstevel@tonic-gate estr = sstr; 21467c478bd9Sstevel@tonic-gate else { 21477c478bd9Sstevel@tonic-gate /* 21487c478bd9Sstevel@tonic-gate * Translate token to uppercase. Don't 21497c478bd9Sstevel@tonic-gate * use toupper(3C) as including this 21507c478bd9Sstevel@tonic-gate * code doubles the size of ld.so.1. 21517c478bd9Sstevel@tonic-gate */ 21527c478bd9Sstevel@tonic-gate if ((*sstr >= 'a') && (*sstr <= 'z')) 21537c478bd9Sstevel@tonic-gate *sstr = *sstr - ('a' - 'A'); 21547c478bd9Sstevel@tonic-gate } 21557c478bd9Sstevel@tonic-gate } 21567c478bd9Sstevel@tonic-gate continue; 21577c478bd9Sstevel@tonic-gate } 21587c478bd9Sstevel@tonic-gate 21597c478bd9Sstevel@tonic-gate *sstr = '\0'; 21607c478bd9Sstevel@tonic-gate if (estr) { 21617c478bd9Sstevel@tonic-gate nlen = estr - nstr; 21627c478bd9Sstevel@tonic-gate if ((*++estr == '\0') || (*estr == ',')) 216343d7826aSRod Evans estr = NULL; 21647c478bd9Sstevel@tonic-gate } else 21657c478bd9Sstevel@tonic-gate nlen = sstr - nstr; 21667c478bd9Sstevel@tonic-gate 21677c478bd9Sstevel@tonic-gate /* 21687c478bd9Sstevel@tonic-gate * Fabricate a boolean definition for any unqualified variable. 21697c478bd9Sstevel@tonic-gate * Thus LD_FLAGS=bind_now is represented as BIND_NOW=(null). 21707c478bd9Sstevel@tonic-gate * The value is sufficient to assert any boolean variables, plus 21717c478bd9Sstevel@tonic-gate * the term "(null)" is specifically chosen in case someone 21727c478bd9Sstevel@tonic-gate * mistakenly supplies something like LD_FLAGS=library_path. 21737c478bd9Sstevel@tonic-gate */ 21743dbfc803SRod Evans if (estr == NULL) 21757c478bd9Sstevel@tonic-gate estr = (char *)MSG_INTL(MSG_STR_NULL); 21767c478bd9Sstevel@tonic-gate 21777c478bd9Sstevel@tonic-gate /* 21787c478bd9Sstevel@tonic-gate * Determine whether the environment variable is 32- or 64-bit 21797c478bd9Sstevel@tonic-gate * specific. The length, len, will reflect the architecture 21807c478bd9Sstevel@tonic-gate * neutral portion of the string. 21817c478bd9Sstevel@tonic-gate */ 21827c478bd9Sstevel@tonic-gate if ((flags = ld_arch_env(nstr, &nlen)) != ENV_TYP_IGNORE) { 21837c478bd9Sstevel@tonic-gate ld_generic_env(nstr, nlen, estr, lmflags, 21847c478bd9Sstevel@tonic-gate lmtflags, (env_flags | flags), aout); 21857c478bd9Sstevel@tonic-gate } 21867c478bd9Sstevel@tonic-gate if (len == 0) 21877c478bd9Sstevel@tonic-gate return (0); 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate nstr = sstr + 1; 219043d7826aSRod Evans estr = NULL; 21917c478bd9Sstevel@tonic-gate } 21927c478bd9Sstevel@tonic-gate return (0); 21937c478bd9Sstevel@tonic-gate } 21947c478bd9Sstevel@tonic-gate 21957c478bd9Sstevel@tonic-gate 21967c478bd9Sstevel@tonic-gate /* 21977c478bd9Sstevel@tonic-gate * Process a single environment string. Only strings starting with `LD_' are 21987c478bd9Sstevel@tonic-gate * reserved for our use. By convention, all strings should be of the form 21997c478bd9Sstevel@tonic-gate * `LD_XXXX=', if the string is followed by a non-null value the appropriate 22007c478bd9Sstevel@tonic-gate * functionality is enabled. Also pick off applicable locale variables. 22017c478bd9Sstevel@tonic-gate */ 22027c478bd9Sstevel@tonic-gate #define LOC_LANG 1 22037c478bd9Sstevel@tonic-gate #define LOC_MESG 2 22047c478bd9Sstevel@tonic-gate #define LOC_ALL 3 22057c478bd9Sstevel@tonic-gate 22067c478bd9Sstevel@tonic-gate static void 22077c478bd9Sstevel@tonic-gate ld_str_env(const char *s1, Word *lmflags, Word *lmtflags, uint_t env_flags, 22087c478bd9Sstevel@tonic-gate int aout) 22097c478bd9Sstevel@tonic-gate { 22107c478bd9Sstevel@tonic-gate const char *s2; 221110a4fa49Srie static size_t loc = 0; 22127c478bd9Sstevel@tonic-gate 22137c478bd9Sstevel@tonic-gate if (*s1++ != 'L') 22147c478bd9Sstevel@tonic-gate return; 22157c478bd9Sstevel@tonic-gate 22167c478bd9Sstevel@tonic-gate /* 22177c478bd9Sstevel@tonic-gate * See if we have any locale environment settings. These environment 22187c478bd9Sstevel@tonic-gate * variables have a precedence, LC_ALL is higher than LC_MESSAGES which 22197c478bd9Sstevel@tonic-gate * is higher than LANG. 22207c478bd9Sstevel@tonic-gate */ 22217c478bd9Sstevel@tonic-gate s2 = s1; 22227c478bd9Sstevel@tonic-gate if ((*s2++ == 'C') && (*s2++ == '_') && (*s2 != '\0')) { 22237c478bd9Sstevel@tonic-gate if (strncmp(s2, MSG_ORIG(MSG_LC_ALL), MSG_LC_ALL_SIZE) == 0) { 22247c478bd9Sstevel@tonic-gate s2 += MSG_LC_ALL_SIZE; 22257c478bd9Sstevel@tonic-gate if ((*s2 != '\0') && (loc < LOC_ALL)) { 222610a4fa49Srie glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2; 22277c478bd9Sstevel@tonic-gate loc = LOC_ALL; 22287c478bd9Sstevel@tonic-gate } 22297c478bd9Sstevel@tonic-gate } else if (strncmp(s2, MSG_ORIG(MSG_LC_MESSAGES), 22307c478bd9Sstevel@tonic-gate MSG_LC_MESSAGES_SIZE) == 0) { 22317c478bd9Sstevel@tonic-gate s2 += MSG_LC_MESSAGES_SIZE; 22327c478bd9Sstevel@tonic-gate if ((*s2 != '\0') && (loc < LOC_MESG)) { 223310a4fa49Srie glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2; 22347c478bd9Sstevel@tonic-gate loc = LOC_MESG; 22357c478bd9Sstevel@tonic-gate } 22367c478bd9Sstevel@tonic-gate } 22377c478bd9Sstevel@tonic-gate return; 22387c478bd9Sstevel@tonic-gate } 22397c478bd9Sstevel@tonic-gate 22407c478bd9Sstevel@tonic-gate s2 = s1; 22417c478bd9Sstevel@tonic-gate if ((*s2++ == 'A') && (*s2++ == 'N') && (*s2++ == 'G') && 22427c478bd9Sstevel@tonic-gate (*s2++ == '=') && (*s2 != '\0') && (loc < LOC_LANG)) { 224310a4fa49Srie glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2; 22447c478bd9Sstevel@tonic-gate loc = LOC_LANG; 22457c478bd9Sstevel@tonic-gate return; 22467c478bd9Sstevel@tonic-gate } 22477c478bd9Sstevel@tonic-gate 22487c478bd9Sstevel@tonic-gate /* 22497c478bd9Sstevel@tonic-gate * Pick off any LD_XXXX environment variables. 22507c478bd9Sstevel@tonic-gate */ 22517c478bd9Sstevel@tonic-gate if ((*s1++ == 'D') && (*s1++ == '_') && (*s1 != '\0')) { 22527c478bd9Sstevel@tonic-gate size_t len; 22537c478bd9Sstevel@tonic-gate int flags; 22547c478bd9Sstevel@tonic-gate 22559acbbeafSnn /* 22569acbbeafSnn * In a branded process we must ignore all LD_XXXX env vars 22579acbbeafSnn * because they are intended for the brand's linker. 22589acbbeafSnn * To affect the Solaris linker, use LD_BRAND_XXXX instead. 22599acbbeafSnn */ 22609acbbeafSnn if (rtld_flags2 & RT_FL2_BRANDED) { 22619acbbeafSnn if (strncmp(s1, MSG_ORIG(MSG_LD_BRAND_PREFIX), 22629acbbeafSnn MSG_LD_BRAND_PREFIX_SIZE) != 0) 22639acbbeafSnn return; 22649acbbeafSnn s1 += MSG_LD_BRAND_PREFIX_SIZE; 22659acbbeafSnn } 22669acbbeafSnn 22677c478bd9Sstevel@tonic-gate /* 22687c478bd9Sstevel@tonic-gate * Environment variables with no value (ie. LD_XXXX=) typically 22697c478bd9Sstevel@tonic-gate * have no impact, however if environment variables are defined 22707c478bd9Sstevel@tonic-gate * within a configuration file, these null user settings can be 22717c478bd9Sstevel@tonic-gate * used to disable any configuration replaceable definitions. 22727c478bd9Sstevel@tonic-gate */ 22733dbfc803SRod Evans if ((s2 = strchr(s1, '=')) == NULL) { 22747c478bd9Sstevel@tonic-gate len = strlen(s1); 227543d7826aSRod Evans s2 = NULL; 22767c478bd9Sstevel@tonic-gate } else if (*++s2 == '\0') { 22777c478bd9Sstevel@tonic-gate len = strlen(s1) - 1; 227843d7826aSRod Evans s2 = NULL; 22797c478bd9Sstevel@tonic-gate } else { 22807c478bd9Sstevel@tonic-gate len = s2 - s1 - 1; 2281e23c41c9SAli Bahrami while (conv_strproc_isspace(*s2)) 22827c478bd9Sstevel@tonic-gate s2++; 22837c478bd9Sstevel@tonic-gate } 22847c478bd9Sstevel@tonic-gate 22857c478bd9Sstevel@tonic-gate /* 22867c478bd9Sstevel@tonic-gate * Determine whether the environment variable is 32- or 64-bit 22877c478bd9Sstevel@tonic-gate * specific. The length, len, will reflect the architecture 22887c478bd9Sstevel@tonic-gate * neutral portion of the string. 22897c478bd9Sstevel@tonic-gate */ 22907c478bd9Sstevel@tonic-gate if ((flags = ld_arch_env(s1, &len)) == ENV_TYP_IGNORE) 22917c478bd9Sstevel@tonic-gate return; 22927c478bd9Sstevel@tonic-gate env_flags |= flags; 22937c478bd9Sstevel@tonic-gate 22947c478bd9Sstevel@tonic-gate ld_generic_env(s1, len, s2, lmflags, lmtflags, env_flags, aout); 22957c478bd9Sstevel@tonic-gate } 22967c478bd9Sstevel@tonic-gate } 22977c478bd9Sstevel@tonic-gate 22987c478bd9Sstevel@tonic-gate /* 22997c478bd9Sstevel@tonic-gate * Internal getenv routine. Called immediately after ld.so.1 initializes 23007c478bd9Sstevel@tonic-gate * itself. 23017c478bd9Sstevel@tonic-gate */ 23027c478bd9Sstevel@tonic-gate int 230356deab07SRod Evans readenv_user(const char **envp, Word *lmflags, Word *lmtflags, int aout) 23047c478bd9Sstevel@tonic-gate { 230510a4fa49Srie char *locale; 230610a4fa49Srie 230756deab07SRod Evans if (envp == NULL) 23087c478bd9Sstevel@tonic-gate return (0); 23097c478bd9Sstevel@tonic-gate 231056deab07SRod Evans while (*envp != NULL) 23117c478bd9Sstevel@tonic-gate ld_str_env(*envp++, lmflags, lmtflags, 0, aout); 23127c478bd9Sstevel@tonic-gate 23137c478bd9Sstevel@tonic-gate /* 23147c478bd9Sstevel@tonic-gate * Having collected the best representation of any LD_FLAGS, process 23157c478bd9Sstevel@tonic-gate * these strings. 23167c478bd9Sstevel@tonic-gate */ 23177c478bd9Sstevel@tonic-gate if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1) 23187c478bd9Sstevel@tonic-gate return (1); 23197c478bd9Sstevel@tonic-gate 23207c478bd9Sstevel@tonic-gate /* 23217c478bd9Sstevel@tonic-gate * Don't allow environment controlled auditing when tracing or if 23227c478bd9Sstevel@tonic-gate * explicitly disabled. Trigger all tracing modes from 23237c478bd9Sstevel@tonic-gate * LML_FLG_TRC_ENABLE. 23247c478bd9Sstevel@tonic-gate */ 23257c478bd9Sstevel@tonic-gate if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT)) 232656deab07SRod Evans rpl_audit = profile_lib = profile_name = NULL; 23277c478bd9Sstevel@tonic-gate if ((*lmflags & LML_FLG_TRC_ENABLE) == 0) 23287c478bd9Sstevel@tonic-gate *lmflags &= ~LML_MSK_TRC; 23297c478bd9Sstevel@tonic-gate 2330dffec89cSrie /* 2331dffec89cSrie * If both LD_BIND_NOW and LD_BIND_LAZY are specified, the former wins. 2332dffec89cSrie */ 2333dffec89cSrie if ((rtld_flags2 & (RT_FL2_BINDNOW | RT_FL2_BINDLAZY)) == 2334dffec89cSrie (RT_FL2_BINDNOW | RT_FL2_BINDLAZY)) 2335dffec89cSrie rtld_flags2 &= ~RT_FL2_BINDLAZY; 2336dffec89cSrie 2337dae2dfb7Srie /* 2338dae2dfb7Srie * When using ldd(1) -r or -d against an executable, assert -p. 2339dae2dfb7Srie */ 2340dae2dfb7Srie if ((*lmflags & 2341dae2dfb7Srie (LML_FLG_TRC_WARN | LML_FLG_TRC_LDDSTUB)) == LML_FLG_TRC_WARN) 2342dae2dfb7Srie *lmflags |= LML_FLG_TRC_NOPAREXT; 2343dae2dfb7Srie 23447c478bd9Sstevel@tonic-gate /* 23457c478bd9Sstevel@tonic-gate * If we have a locale setting make sure its worth processing further. 23461d6b7ad8Srie * C and POSIX locales don't need any processing. In addition, to 23471d6b7ad8Srie * ensure no one escapes the /usr/lib/locale hierarchy, don't allow 23481d6b7ad8Srie * the locale to contain a segment that leads upward in the file system 23491d6b7ad8Srie * hierarchy (i.e. no '..' segments). Given that we'll be confined to 23501d6b7ad8Srie * the /usr/lib/locale hierarchy, there is no need to extensively 23511d6b7ad8Srie * validate the mode or ownership of any message file (as libc's 23521d6b7ad8Srie * generic handling of message files does). Duplicate the string so 23531d6b7ad8Srie * that new locale setting can generically cleanup any previous locales. 23547c478bd9Sstevel@tonic-gate */ 235543d7826aSRod Evans if ((locale = glcs[CI_LCMESSAGES].lc_un.lc_ptr) != NULL) { 23567c478bd9Sstevel@tonic-gate if (((*locale == 'C') && (*(locale + 1) == '\0')) || 23571d6b7ad8Srie (strcmp(locale, MSG_ORIG(MSG_TKN_POSIX)) == 0) || 23581d6b7ad8Srie (strstr(locale, MSG_ORIG(MSG_TKN_DOTDOT)) != NULL)) 235943d7826aSRod Evans glcs[CI_LCMESSAGES].lc_un.lc_ptr = NULL; 23607c478bd9Sstevel@tonic-gate else 236110a4fa49Srie glcs[CI_LCMESSAGES].lc_un.lc_ptr = strdup(locale); 23627c478bd9Sstevel@tonic-gate } 23637c478bd9Sstevel@tonic-gate return (0); 23647c478bd9Sstevel@tonic-gate } 23657c478bd9Sstevel@tonic-gate 23667c478bd9Sstevel@tonic-gate /* 23677c478bd9Sstevel@tonic-gate * Configuration environment processing. Called after the a.out has been 23687c478bd9Sstevel@tonic-gate * processed (as the a.out can specify its own configuration file). 23697c478bd9Sstevel@tonic-gate */ 23707c478bd9Sstevel@tonic-gate int 23717c478bd9Sstevel@tonic-gate readenv_config(Rtc_env * envtbl, Addr addr, int aout) 23727c478bd9Sstevel@tonic-gate { 23739aa23310Srie Word *lmflags = &(lml_main.lm_flags); 23749aa23310Srie Word *lmtflags = &(lml_main.lm_tflags); 23757c478bd9Sstevel@tonic-gate 237656deab07SRod Evans if (envtbl == NULL) 23777c478bd9Sstevel@tonic-gate return (0); 23787c478bd9Sstevel@tonic-gate 23797c478bd9Sstevel@tonic-gate while (envtbl->env_str) { 23807c478bd9Sstevel@tonic-gate uint_t env_flags = ENV_TYP_CONFIG; 23817c478bd9Sstevel@tonic-gate 23827c478bd9Sstevel@tonic-gate if (envtbl->env_flags & RTC_ENV_PERMANT) 23837c478bd9Sstevel@tonic-gate env_flags |= ENV_TYP_PERMANT; 23847c478bd9Sstevel@tonic-gate 23857c478bd9Sstevel@tonic-gate ld_str_env((const char *)(envtbl->env_str + addr), 23867c478bd9Sstevel@tonic-gate lmflags, lmtflags, env_flags, 0); 23877c478bd9Sstevel@tonic-gate envtbl++; 23887c478bd9Sstevel@tonic-gate } 23897c478bd9Sstevel@tonic-gate 23907c478bd9Sstevel@tonic-gate /* 23917c478bd9Sstevel@tonic-gate * Having collected the best representation of any LD_FLAGS, process 23927c478bd9Sstevel@tonic-gate * these strings. 23937c478bd9Sstevel@tonic-gate */ 23947c478bd9Sstevel@tonic-gate if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1) 23957c478bd9Sstevel@tonic-gate return (1); 23967c478bd9Sstevel@tonic-gate if (ld_flags_env(prm_ldflags, lmflags, lmtflags, ENV_TYP_CONFIG, 23977c478bd9Sstevel@tonic-gate aout) == 1) 23987c478bd9Sstevel@tonic-gate return (1); 23997c478bd9Sstevel@tonic-gate 24007c478bd9Sstevel@tonic-gate /* 24017c478bd9Sstevel@tonic-gate * Don't allow environment controlled auditing when tracing or if 24027c478bd9Sstevel@tonic-gate * explicitly disabled. Trigger all tracing modes from 24037c478bd9Sstevel@tonic-gate * LML_FLG_TRC_ENABLE. 24047c478bd9Sstevel@tonic-gate */ 24057c478bd9Sstevel@tonic-gate if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT)) 240656deab07SRod Evans prm_audit = profile_lib = profile_name = NULL; 24077c478bd9Sstevel@tonic-gate if ((*lmflags & LML_FLG_TRC_ENABLE) == 0) 24087c478bd9Sstevel@tonic-gate *lmflags &= ~LML_MSK_TRC; 24097c478bd9Sstevel@tonic-gate 24107c478bd9Sstevel@tonic-gate return (0); 24117c478bd9Sstevel@tonic-gate } 24127c478bd9Sstevel@tonic-gate 24137c478bd9Sstevel@tonic-gate int 24147c478bd9Sstevel@tonic-gate dowrite(Prfbuf * prf) 24157c478bd9Sstevel@tonic-gate { 24167c478bd9Sstevel@tonic-gate /* 24177c478bd9Sstevel@tonic-gate * We do not have a valid file descriptor, so we are unable 24187c478bd9Sstevel@tonic-gate * to flush the buffer. 24197c478bd9Sstevel@tonic-gate */ 24207c478bd9Sstevel@tonic-gate if (prf->pr_fd == -1) 24217c478bd9Sstevel@tonic-gate return (0); 24227c478bd9Sstevel@tonic-gate (void) write(prf->pr_fd, prf->pr_buf, prf->pr_cur - prf->pr_buf); 24237c478bd9Sstevel@tonic-gate prf->pr_cur = prf->pr_buf; 24247c478bd9Sstevel@tonic-gate return (1); 24257c478bd9Sstevel@tonic-gate } 24267c478bd9Sstevel@tonic-gate 24277c478bd9Sstevel@tonic-gate /* 24287c478bd9Sstevel@tonic-gate * Simplified printing. The following conversion specifications are supported: 24297c478bd9Sstevel@tonic-gate * 24307c478bd9Sstevel@tonic-gate * % [#] [-] [min field width] [. precision] s|d|x|c 24317c478bd9Sstevel@tonic-gate * 24327c478bd9Sstevel@tonic-gate * 24337c478bd9Sstevel@tonic-gate * dorprf takes the output buffer in the form of Prfbuf which permits 24347c478bd9Sstevel@tonic-gate * the verification of the output buffer size and the concatenation 24357c478bd9Sstevel@tonic-gate * of data to an already existing output buffer. The Prfbuf 24367c478bd9Sstevel@tonic-gate * structure contains the following: 24377c478bd9Sstevel@tonic-gate * 24387c478bd9Sstevel@tonic-gate * pr_buf pointer to the beginning of the output buffer. 24397c478bd9Sstevel@tonic-gate * pr_cur pointer to the next available byte in the output buffer. By 24407c478bd9Sstevel@tonic-gate * setting pr_cur ahead of pr_buf you can append to an already 24417c478bd9Sstevel@tonic-gate * existing buffer. 24427c478bd9Sstevel@tonic-gate * pr_len the size of the output buffer. By setting pr_len to '0' you 24437c478bd9Sstevel@tonic-gate * disable protection from overflows in the output buffer. 24447c478bd9Sstevel@tonic-gate * pr_fd a pointer to the file-descriptor the buffer will eventually be 24457c478bd9Sstevel@tonic-gate * output to. If pr_fd is set to '-1' then it's assumed there is 24461d6b7ad8Srie * no output buffer, and doprf() will return with an error to 24471d6b7ad8Srie * indicate an output buffer overflow. If pr_fd is > -1 then when 24481d6b7ad8Srie * the output buffer is filled it will be flushed to pr_fd and will 24491d6b7ad8Srie * then be available for additional data. 24507c478bd9Sstevel@tonic-gate */ 24517c478bd9Sstevel@tonic-gate #define FLG_UT_MINUS 0x0001 /* - */ 24527c478bd9Sstevel@tonic-gate #define FLG_UT_SHARP 0x0002 /* # */ 24537c478bd9Sstevel@tonic-gate #define FLG_UT_DOTSEEN 0x0008 /* dot appeared in format spec */ 24547c478bd9Sstevel@tonic-gate 24557c478bd9Sstevel@tonic-gate /* 245610a4fa49Srie * This macro is for use from within doprf only. It is to be used for checking 245710a4fa49Srie * the output buffer size and placing characters into the buffer. 24587c478bd9Sstevel@tonic-gate */ 24597c478bd9Sstevel@tonic-gate #define PUTC(c) \ 24607c478bd9Sstevel@tonic-gate { \ 246110a4fa49Srie char tmpc; \ 24627c478bd9Sstevel@tonic-gate \ 24637c478bd9Sstevel@tonic-gate tmpc = (c); \ 246410a4fa49Srie if (bufsiz && (bp >= bufend)) { \ 24657c478bd9Sstevel@tonic-gate prf->pr_cur = bp; \ 24667c478bd9Sstevel@tonic-gate if (dowrite(prf) == 0) \ 24677c478bd9Sstevel@tonic-gate return (0); \ 24687c478bd9Sstevel@tonic-gate bp = prf->pr_cur; \ 24697c478bd9Sstevel@tonic-gate } \ 24707c478bd9Sstevel@tonic-gate *bp++ = tmpc; \ 24717c478bd9Sstevel@tonic-gate } 24727c478bd9Sstevel@tonic-gate 24731d6b7ad8Srie /* 24741d6b7ad8Srie * Define a local buffer size for building a numeric value - large enough to 24751d6b7ad8Srie * hold a 64-bit value. 24761d6b7ad8Srie */ 2477051d39bbSrie #define NUM_SIZE 22 24781d6b7ad8Srie 24797c478bd9Sstevel@tonic-gate size_t 24807c478bd9Sstevel@tonic-gate doprf(const char *format, va_list args, Prfbuf *prf) 24817c478bd9Sstevel@tonic-gate { 24827c478bd9Sstevel@tonic-gate char c; 24837c478bd9Sstevel@tonic-gate char *bp = prf->pr_cur; 24847c478bd9Sstevel@tonic-gate char *bufend = prf->pr_buf + prf->pr_len; 24857c478bd9Sstevel@tonic-gate size_t bufsiz = prf->pr_len; 24867c478bd9Sstevel@tonic-gate 24877c478bd9Sstevel@tonic-gate while ((c = *format++) != '\0') { 24887c478bd9Sstevel@tonic-gate if (c != '%') { 24897c478bd9Sstevel@tonic-gate PUTC(c); 24907c478bd9Sstevel@tonic-gate } else { 24917c478bd9Sstevel@tonic-gate int base = 0, flag = 0, width = 0, prec = 0; 24927c478bd9Sstevel@tonic-gate size_t _i; 24937c478bd9Sstevel@tonic-gate int _c, _n; 24947c478bd9Sstevel@tonic-gate char *_s; 24957c478bd9Sstevel@tonic-gate int ls = 0; 24967c478bd9Sstevel@tonic-gate again: 24977c478bd9Sstevel@tonic-gate c = *format++; 24987c478bd9Sstevel@tonic-gate switch (c) { 24997c478bd9Sstevel@tonic-gate case '-': 25007c478bd9Sstevel@tonic-gate flag |= FLG_UT_MINUS; 25017c478bd9Sstevel@tonic-gate goto again; 25027c478bd9Sstevel@tonic-gate case '#': 25037c478bd9Sstevel@tonic-gate flag |= FLG_UT_SHARP; 25047c478bd9Sstevel@tonic-gate goto again; 25057c478bd9Sstevel@tonic-gate case '.': 25067c478bd9Sstevel@tonic-gate flag |= FLG_UT_DOTSEEN; 25077c478bd9Sstevel@tonic-gate goto again; 25087c478bd9Sstevel@tonic-gate case '0': 25097c478bd9Sstevel@tonic-gate case '1': 25107c478bd9Sstevel@tonic-gate case '2': 25117c478bd9Sstevel@tonic-gate case '3': 25127c478bd9Sstevel@tonic-gate case '4': 25137c478bd9Sstevel@tonic-gate case '5': 25147c478bd9Sstevel@tonic-gate case '6': 25157c478bd9Sstevel@tonic-gate case '7': 25167c478bd9Sstevel@tonic-gate case '8': 25177c478bd9Sstevel@tonic-gate case '9': 25187c478bd9Sstevel@tonic-gate if (flag & FLG_UT_DOTSEEN) 25197c478bd9Sstevel@tonic-gate prec = (prec * 10) + c - '0'; 25207c478bd9Sstevel@tonic-gate else 25217c478bd9Sstevel@tonic-gate width = (width * 10) + c - '0'; 25227c478bd9Sstevel@tonic-gate goto again; 25237c478bd9Sstevel@tonic-gate case 'x': 25247c478bd9Sstevel@tonic-gate case 'X': 25257c478bd9Sstevel@tonic-gate base = 16; 25267c478bd9Sstevel@tonic-gate break; 25277c478bd9Sstevel@tonic-gate case 'd': 25287c478bd9Sstevel@tonic-gate case 'D': 25297c478bd9Sstevel@tonic-gate case 'u': 25307c478bd9Sstevel@tonic-gate base = 10; 25317c478bd9Sstevel@tonic-gate flag &= ~FLG_UT_SHARP; 25327c478bd9Sstevel@tonic-gate break; 25337c478bd9Sstevel@tonic-gate case 'l': 25347c478bd9Sstevel@tonic-gate base = 10; 25357c478bd9Sstevel@tonic-gate ls++; /* number of l's (long or long long) */ 25367c478bd9Sstevel@tonic-gate if ((*format == 'l') || 25377c478bd9Sstevel@tonic-gate (*format == 'd') || (*format == 'D') || 25387c478bd9Sstevel@tonic-gate (*format == 'x') || (*format == 'X') || 253920272c2eSAli Bahrami (*format == 'o') || (*format == 'O') || 254020272c2eSAli Bahrami (*format == 'u') || (*format == 'U')) 25417c478bd9Sstevel@tonic-gate goto again; 25427c478bd9Sstevel@tonic-gate break; 25437c478bd9Sstevel@tonic-gate case 'o': 25447c478bd9Sstevel@tonic-gate case 'O': 25457c478bd9Sstevel@tonic-gate base = 8; 25467c478bd9Sstevel@tonic-gate break; 25477c478bd9Sstevel@tonic-gate case 'c': 25487c478bd9Sstevel@tonic-gate _c = va_arg(args, int); 25497c478bd9Sstevel@tonic-gate 25507c478bd9Sstevel@tonic-gate for (_i = 24; _i > 0; _i -= 8) { 25517c478bd9Sstevel@tonic-gate if ((c = ((_c >> _i) & 0x7f)) != 0) { 25527c478bd9Sstevel@tonic-gate PUTC(c); 25537c478bd9Sstevel@tonic-gate } 25547c478bd9Sstevel@tonic-gate } 25557c478bd9Sstevel@tonic-gate if ((c = ((_c >> _i) & 0x7f)) != 0) { 25567c478bd9Sstevel@tonic-gate PUTC(c); 25577c478bd9Sstevel@tonic-gate } 25587c478bd9Sstevel@tonic-gate break; 25597c478bd9Sstevel@tonic-gate case 's': 25607c478bd9Sstevel@tonic-gate _s = va_arg(args, char *); 25617c478bd9Sstevel@tonic-gate _i = strlen(_s); 25627c478bd9Sstevel@tonic-gate /* LINTED */ 25637c478bd9Sstevel@tonic-gate _n = (int)(width - _i); 25647c478bd9Sstevel@tonic-gate if (!prec) 25657c478bd9Sstevel@tonic-gate /* LINTED */ 25667c478bd9Sstevel@tonic-gate prec = (int)_i; 25677c478bd9Sstevel@tonic-gate 25687c478bd9Sstevel@tonic-gate if (width && !(flag & FLG_UT_MINUS)) { 25697c478bd9Sstevel@tonic-gate while (_n-- > 0) 25707c478bd9Sstevel@tonic-gate PUTC(' '); 25717c478bd9Sstevel@tonic-gate } 25727c478bd9Sstevel@tonic-gate while (((c = *_s++) != 0) && prec--) { 25737c478bd9Sstevel@tonic-gate PUTC(c); 25747c478bd9Sstevel@tonic-gate } 25757c478bd9Sstevel@tonic-gate if (width && (flag & FLG_UT_MINUS)) { 25767c478bd9Sstevel@tonic-gate while (_n-- > 0) 25777c478bd9Sstevel@tonic-gate PUTC(' '); 25787c478bd9Sstevel@tonic-gate } 25797c478bd9Sstevel@tonic-gate break; 25807c478bd9Sstevel@tonic-gate case '%': 25817c478bd9Sstevel@tonic-gate PUTC('%'); 25827c478bd9Sstevel@tonic-gate break; 25837c478bd9Sstevel@tonic-gate default: 25847c478bd9Sstevel@tonic-gate break; 25857c478bd9Sstevel@tonic-gate } 25867c478bd9Sstevel@tonic-gate 25877c478bd9Sstevel@tonic-gate /* 25887c478bd9Sstevel@tonic-gate * Numeric processing 25897c478bd9Sstevel@tonic-gate */ 25907c478bd9Sstevel@tonic-gate if (base) { 25911d6b7ad8Srie char local[NUM_SIZE]; 25921d6b7ad8Srie size_t ssize = 0, psize = 0; 25937c478bd9Sstevel@tonic-gate const char *string = 2594a953e2b1Srie MSG_ORIG(MSG_STR_HEXNUM); 25957c478bd9Sstevel@tonic-gate const char *prefix = 2596a953e2b1Srie MSG_ORIG(MSG_STR_EMPTY); 25977c478bd9Sstevel@tonic-gate u_longlong_t num; 25987c478bd9Sstevel@tonic-gate 25997c478bd9Sstevel@tonic-gate switch (ls) { 26007c478bd9Sstevel@tonic-gate case 0: /* int */ 26017c478bd9Sstevel@tonic-gate num = (u_longlong_t) 26027c478bd9Sstevel@tonic-gate va_arg(args, uint_t); 26037c478bd9Sstevel@tonic-gate break; 26047c478bd9Sstevel@tonic-gate case 1: /* long */ 26057c478bd9Sstevel@tonic-gate num = (u_longlong_t) 26067c478bd9Sstevel@tonic-gate va_arg(args, ulong_t); 26077c478bd9Sstevel@tonic-gate break; 26087c478bd9Sstevel@tonic-gate case 2: /* long long */ 26097c478bd9Sstevel@tonic-gate num = va_arg(args, u_longlong_t); 26107c478bd9Sstevel@tonic-gate break; 26117c478bd9Sstevel@tonic-gate } 26127c478bd9Sstevel@tonic-gate 26137c478bd9Sstevel@tonic-gate if (flag & FLG_UT_SHARP) { 26147c478bd9Sstevel@tonic-gate if (base == 16) { 26157c478bd9Sstevel@tonic-gate prefix = MSG_ORIG(MSG_STR_HEX); 26167c478bd9Sstevel@tonic-gate psize = 2; 26177c478bd9Sstevel@tonic-gate } else { 26187c478bd9Sstevel@tonic-gate prefix = MSG_ORIG(MSG_STR_ZERO); 26197c478bd9Sstevel@tonic-gate psize = 1; 26207c478bd9Sstevel@tonic-gate } 26217c478bd9Sstevel@tonic-gate } 26227c478bd9Sstevel@tonic-gate if ((base == 10) && (long)num < 0) { 26237c478bd9Sstevel@tonic-gate prefix = MSG_ORIG(MSG_STR_NEGATE); 26247c478bd9Sstevel@tonic-gate psize = MSG_STR_NEGATE_SIZE; 26257c478bd9Sstevel@tonic-gate num = (u_longlong_t)(-(longlong_t)num); 26267c478bd9Sstevel@tonic-gate } 26277c478bd9Sstevel@tonic-gate 26287c478bd9Sstevel@tonic-gate /* 26297c478bd9Sstevel@tonic-gate * Convert the numeric value into a local 26307c478bd9Sstevel@tonic-gate * string (stored in reverse order). 26317c478bd9Sstevel@tonic-gate */ 26327c478bd9Sstevel@tonic-gate _s = local; 26337c478bd9Sstevel@tonic-gate do { 26347c478bd9Sstevel@tonic-gate *_s++ = string[num % base]; 26357c478bd9Sstevel@tonic-gate num /= base; 26367c478bd9Sstevel@tonic-gate ssize++; 26377c478bd9Sstevel@tonic-gate } while (num); 26387c478bd9Sstevel@tonic-gate 26391d6b7ad8Srie ASSERT(ssize < sizeof (local)); 26401d6b7ad8Srie 26417c478bd9Sstevel@tonic-gate /* 26427c478bd9Sstevel@tonic-gate * Provide any precision or width padding. 26437c478bd9Sstevel@tonic-gate */ 26447c478bd9Sstevel@tonic-gate if (prec) { 26457c478bd9Sstevel@tonic-gate /* LINTED */ 26467c478bd9Sstevel@tonic-gate _n = (int)(prec - ssize); 26471d6b7ad8Srie while ((_n-- > 0) && 26481d6b7ad8Srie (ssize < sizeof (local))) { 26497c478bd9Sstevel@tonic-gate *_s++ = '0'; 26507c478bd9Sstevel@tonic-gate ssize++; 26517c478bd9Sstevel@tonic-gate } 26527c478bd9Sstevel@tonic-gate } 26537c478bd9Sstevel@tonic-gate if (width && !(flag & FLG_UT_MINUS)) { 26547c478bd9Sstevel@tonic-gate /* LINTED */ 26557c478bd9Sstevel@tonic-gate _n = (int)(width - ssize - psize); 26567c478bd9Sstevel@tonic-gate while (_n-- > 0) { 26577c478bd9Sstevel@tonic-gate PUTC(' '); 26587c478bd9Sstevel@tonic-gate } 26597c478bd9Sstevel@tonic-gate } 26607c478bd9Sstevel@tonic-gate 26617c478bd9Sstevel@tonic-gate /* 26627c478bd9Sstevel@tonic-gate * Print any prefix and the numeric string 26637c478bd9Sstevel@tonic-gate */ 26647c478bd9Sstevel@tonic-gate while (*prefix) 26657c478bd9Sstevel@tonic-gate PUTC(*prefix++); 26667c478bd9Sstevel@tonic-gate do { 26677c478bd9Sstevel@tonic-gate PUTC(*--_s); 26687c478bd9Sstevel@tonic-gate } while (_s > local); 26697c478bd9Sstevel@tonic-gate 26707c478bd9Sstevel@tonic-gate /* 26717c478bd9Sstevel@tonic-gate * Provide any width padding. 26727c478bd9Sstevel@tonic-gate */ 26737c478bd9Sstevel@tonic-gate if (width && (flag & FLG_UT_MINUS)) { 26747c478bd9Sstevel@tonic-gate /* LINTED */ 26757c478bd9Sstevel@tonic-gate _n = (int)(width - ssize - psize); 26767c478bd9Sstevel@tonic-gate while (_n-- > 0) 26777c478bd9Sstevel@tonic-gate PUTC(' '); 26787c478bd9Sstevel@tonic-gate } 26797c478bd9Sstevel@tonic-gate } 26807c478bd9Sstevel@tonic-gate } 26817c478bd9Sstevel@tonic-gate } 268210a4fa49Srie 26837c478bd9Sstevel@tonic-gate PUTC('\0'); 26847c478bd9Sstevel@tonic-gate prf->pr_cur = bp; 26857c478bd9Sstevel@tonic-gate return (1); 26867c478bd9Sstevel@tonic-gate } 26877c478bd9Sstevel@tonic-gate 26887c478bd9Sstevel@tonic-gate static int 26897c478bd9Sstevel@tonic-gate doprintf(const char *format, va_list args, Prfbuf *prf) 26907c478bd9Sstevel@tonic-gate { 26917c478bd9Sstevel@tonic-gate char *ocur = prf->pr_cur; 26927c478bd9Sstevel@tonic-gate 26937c478bd9Sstevel@tonic-gate if (doprf(format, args, prf) == 0) 26947c478bd9Sstevel@tonic-gate return (0); 26957c478bd9Sstevel@tonic-gate /* LINTED */ 26967c478bd9Sstevel@tonic-gate return ((int)(prf->pr_cur - ocur)); 26977c478bd9Sstevel@tonic-gate } 26987c478bd9Sstevel@tonic-gate 26997c478bd9Sstevel@tonic-gate /* VARARGS2 */ 27007c478bd9Sstevel@tonic-gate int 27017c478bd9Sstevel@tonic-gate sprintf(char *buf, const char *format, ...) 27027c478bd9Sstevel@tonic-gate { 27037c478bd9Sstevel@tonic-gate va_list args; 27047c478bd9Sstevel@tonic-gate int len; 27057c478bd9Sstevel@tonic-gate Prfbuf prf; 27067c478bd9Sstevel@tonic-gate 27077c478bd9Sstevel@tonic-gate va_start(args, format); 27087c478bd9Sstevel@tonic-gate prf.pr_buf = prf.pr_cur = buf; 27097c478bd9Sstevel@tonic-gate prf.pr_len = 0; 27107c478bd9Sstevel@tonic-gate prf.pr_fd = -1; 27117c478bd9Sstevel@tonic-gate len = doprintf(format, args, &prf); 27127c478bd9Sstevel@tonic-gate va_end(args); 27137c478bd9Sstevel@tonic-gate 27147c478bd9Sstevel@tonic-gate /* 27157c478bd9Sstevel@tonic-gate * sprintf() return value excludes the terminating null byte. 27167c478bd9Sstevel@tonic-gate */ 27177c478bd9Sstevel@tonic-gate return (len - 1); 27187c478bd9Sstevel@tonic-gate } 27197c478bd9Sstevel@tonic-gate 27207c478bd9Sstevel@tonic-gate /* VARARGS3 */ 27217c478bd9Sstevel@tonic-gate int 27227c478bd9Sstevel@tonic-gate snprintf(char *buf, size_t n, const char *format, ...) 27237c478bd9Sstevel@tonic-gate { 27247c478bd9Sstevel@tonic-gate va_list args; 27257c478bd9Sstevel@tonic-gate int len; 27267c478bd9Sstevel@tonic-gate Prfbuf prf; 27277c478bd9Sstevel@tonic-gate 27287c478bd9Sstevel@tonic-gate va_start(args, format); 27297c478bd9Sstevel@tonic-gate prf.pr_buf = prf.pr_cur = buf; 27307c478bd9Sstevel@tonic-gate prf.pr_len = n; 27317c478bd9Sstevel@tonic-gate prf.pr_fd = -1; 27327c478bd9Sstevel@tonic-gate len = doprintf(format, args, &prf); 27337c478bd9Sstevel@tonic-gate va_end(args); 27347c478bd9Sstevel@tonic-gate 27357c478bd9Sstevel@tonic-gate return (len); 27367c478bd9Sstevel@tonic-gate } 27377c478bd9Sstevel@tonic-gate 27387c478bd9Sstevel@tonic-gate /* VARARGS2 */ 27397c478bd9Sstevel@tonic-gate int 27407c478bd9Sstevel@tonic-gate bufprint(Prfbuf *prf, const char *format, ...) 27417c478bd9Sstevel@tonic-gate { 27427c478bd9Sstevel@tonic-gate va_list args; 27437c478bd9Sstevel@tonic-gate int len; 27447c478bd9Sstevel@tonic-gate 27457c478bd9Sstevel@tonic-gate va_start(args, format); 27467c478bd9Sstevel@tonic-gate len = doprintf(format, args, prf); 27477c478bd9Sstevel@tonic-gate va_end(args); 27487c478bd9Sstevel@tonic-gate 27497c478bd9Sstevel@tonic-gate return (len); 27507c478bd9Sstevel@tonic-gate } 27517c478bd9Sstevel@tonic-gate 27527c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 27537c478bd9Sstevel@tonic-gate int 27547c478bd9Sstevel@tonic-gate printf(const char *format, ...) 27557c478bd9Sstevel@tonic-gate { 27567c478bd9Sstevel@tonic-gate va_list args; 27577c478bd9Sstevel@tonic-gate char buffer[ERRSIZE]; 27587c478bd9Sstevel@tonic-gate Prfbuf prf; 27597c478bd9Sstevel@tonic-gate 27607c478bd9Sstevel@tonic-gate va_start(args, format); 27617c478bd9Sstevel@tonic-gate prf.pr_buf = prf.pr_cur = buffer; 27627c478bd9Sstevel@tonic-gate prf.pr_len = ERRSIZE; 27637c478bd9Sstevel@tonic-gate prf.pr_fd = 1; 27647c478bd9Sstevel@tonic-gate (void) doprf(format, args, &prf); 27657c478bd9Sstevel@tonic-gate va_end(args); 27667c478bd9Sstevel@tonic-gate /* 27677c478bd9Sstevel@tonic-gate * Trim trailing '\0' form buffer 27687c478bd9Sstevel@tonic-gate */ 27697c478bd9Sstevel@tonic-gate prf.pr_cur--; 27707c478bd9Sstevel@tonic-gate return (dowrite(&prf)); 27717c478bd9Sstevel@tonic-gate } 27727c478bd9Sstevel@tonic-gate 277343d7826aSRod Evans static char errbuf[ERRSIZE], *nextptr = errbuf, *prevptr = NULL; 27747c478bd9Sstevel@tonic-gate 277556deab07SRod Evans /* 277656deab07SRod Evans * All error messages go through eprintf(). During process initialization, 277756deab07SRod Evans * these messages are directed to the standard error, however once control has 277856deab07SRod Evans * been passed to the applications code these messages are stored in an internal 277956deab07SRod Evans * buffer for use with dlerror(). Note, fatal error conditions that may occur 278056deab07SRod Evans * while running the application will still cause a standard error message, see 278156deab07SRod Evans * rtldexit() in this file for details. 278256deab07SRod Evans * The RT_FL_APPLIC flag serves to indicate the transition between process 278356deab07SRod Evans * initialization and when the applications code is running. 278456deab07SRod Evans */ 27855aefb655Srie /*PRINTFLIKE3*/ 27867c478bd9Sstevel@tonic-gate void 27875aefb655Srie eprintf(Lm_list *lml, Error error, const char *format, ...) 27887c478bd9Sstevel@tonic-gate { 27897c478bd9Sstevel@tonic-gate va_list args; 27907c478bd9Sstevel@tonic-gate int overflow = 0; 27917c478bd9Sstevel@tonic-gate static int lock = 0; 27927c478bd9Sstevel@tonic-gate Prfbuf prf; 27937c478bd9Sstevel@tonic-gate 27947c478bd9Sstevel@tonic-gate if (lock || (nextptr == (errbuf + ERRSIZE))) 27957c478bd9Sstevel@tonic-gate return; 27967c478bd9Sstevel@tonic-gate 27977c478bd9Sstevel@tonic-gate /* 27987c478bd9Sstevel@tonic-gate * Note: this lock is here to prevent the same thread from recursively 27997c478bd9Sstevel@tonic-gate * entering itself during a eprintf. ie: during eprintf malloc() fails 28007c478bd9Sstevel@tonic-gate * and we try and call eprintf ... and then malloc() fails .... 28017c478bd9Sstevel@tonic-gate */ 28027c478bd9Sstevel@tonic-gate lock = 1; 28037c478bd9Sstevel@tonic-gate 28047c478bd9Sstevel@tonic-gate /* 28057c478bd9Sstevel@tonic-gate * If we have completed startup initialization, all error messages 28067c478bd9Sstevel@tonic-gate * must be saved. These are reported through dlerror(). If we're 28077c478bd9Sstevel@tonic-gate * still in the initialization stage, output the error directly and 28087c478bd9Sstevel@tonic-gate * add a newline. 28097c478bd9Sstevel@tonic-gate */ 28107c478bd9Sstevel@tonic-gate va_start(args, format); 28117c478bd9Sstevel@tonic-gate 28127c478bd9Sstevel@tonic-gate prf.pr_buf = prf.pr_cur = nextptr; 28137c478bd9Sstevel@tonic-gate prf.pr_len = ERRSIZE - (nextptr - errbuf); 28147c478bd9Sstevel@tonic-gate 28157c478bd9Sstevel@tonic-gate if (!(rtld_flags & RT_FL_APPLIC)) 28167c478bd9Sstevel@tonic-gate prf.pr_fd = 2; 28177c478bd9Sstevel@tonic-gate else 28187c478bd9Sstevel@tonic-gate prf.pr_fd = -1; 28197c478bd9Sstevel@tonic-gate 28207c478bd9Sstevel@tonic-gate if (error > ERR_NONE) { 28217c478bd9Sstevel@tonic-gate if ((error == ERR_FATAL) && (rtld_flags2 & RT_FL2_FTL2WARN)) 28227c478bd9Sstevel@tonic-gate error = ERR_WARNING; 28237c478bd9Sstevel@tonic-gate if (error == ERR_WARNING) { 282443d7826aSRod Evans if (err_strs[ERR_WARNING] == NULL) 2825a953e2b1Srie err_strs[ERR_WARNING] = 2826a953e2b1Srie MSG_INTL(MSG_ERR_WARNING); 28277c478bd9Sstevel@tonic-gate } else if (error == ERR_FATAL) { 282843d7826aSRod Evans if (err_strs[ERR_FATAL] == NULL) 2829a953e2b1Srie err_strs[ERR_FATAL] = MSG_INTL(MSG_ERR_FATAL); 28307c478bd9Sstevel@tonic-gate } else if (error == ERR_ELF) { 283143d7826aSRod Evans if (err_strs[ERR_ELF] == NULL) 2832a953e2b1Srie err_strs[ERR_ELF] = MSG_INTL(MSG_ERR_ELF); 28337c478bd9Sstevel@tonic-gate } 283441072f3cSrie if (procname) { 283541072f3cSrie if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR1), 283641072f3cSrie rtldname, procname, err_strs[error]) == 0) 283741072f3cSrie overflow = 1; 28387c478bd9Sstevel@tonic-gate } else { 283941072f3cSrie if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2), 284041072f3cSrie rtldname, err_strs[error]) == 0) 284141072f3cSrie overflow = 1; 284241072f3cSrie } 284341072f3cSrie if (overflow == 0) { 28447c478bd9Sstevel@tonic-gate /* 28457c478bd9Sstevel@tonic-gate * Remove the terminating '\0'. 28467c478bd9Sstevel@tonic-gate */ 28477c478bd9Sstevel@tonic-gate prf.pr_cur--; 28487c478bd9Sstevel@tonic-gate } 28497c478bd9Sstevel@tonic-gate } 28507c478bd9Sstevel@tonic-gate 28517c478bd9Sstevel@tonic-gate if ((overflow == 0) && doprf(format, args, &prf) == 0) 28527c478bd9Sstevel@tonic-gate overflow = 1; 28537c478bd9Sstevel@tonic-gate 28547c478bd9Sstevel@tonic-gate /* 28557c478bd9Sstevel@tonic-gate * If this is an ELF error, it will have been generated by a support 28567c478bd9Sstevel@tonic-gate * object that has a dependency on libelf. ld.so.1 doesn't generate any 28577c478bd9Sstevel@tonic-gate * ELF error messages as it doesn't interact with libelf. Determine the 28587c478bd9Sstevel@tonic-gate * ELF error string. 28597c478bd9Sstevel@tonic-gate */ 28607c478bd9Sstevel@tonic-gate if ((overflow == 0) && (error == ERR_ELF)) { 28617c478bd9Sstevel@tonic-gate static int (*elfeno)() = 0; 28627c478bd9Sstevel@tonic-gate static const char *(*elfemg)(); 28637c478bd9Sstevel@tonic-gate const char *emsg; 28647c478bd9Sstevel@tonic-gate Rt_map *dlmp, *lmp = lml_rtld.lm_head; 28657c478bd9Sstevel@tonic-gate 28667c478bd9Sstevel@tonic-gate if (NEXT(lmp) && (elfeno == 0)) { 28677c478bd9Sstevel@tonic-gate if (((elfemg = (const char *(*)())dlsym_intn(RTLD_NEXT, 286843d7826aSRod Evans MSG_ORIG(MSG_SYM_ELFERRMSG), 286943d7826aSRod Evans lmp, &dlmp)) == NULL) || 28707c478bd9Sstevel@tonic-gate ((elfeno = (int (*)())dlsym_intn(RTLD_NEXT, 287143d7826aSRod Evans MSG_ORIG(MSG_SYM_ELFERRNO), lmp, &dlmp)) == NULL)) 28727c478bd9Sstevel@tonic-gate elfeno = 0; 28737c478bd9Sstevel@tonic-gate } 28747c478bd9Sstevel@tonic-gate 28757c478bd9Sstevel@tonic-gate /* 28767c478bd9Sstevel@tonic-gate * Lookup the message; equivalent to elf_errmsg(elf_errno()). 28777c478bd9Sstevel@tonic-gate */ 287843d7826aSRod Evans if (elfeno && ((emsg = (* elfemg)((* elfeno)())) != NULL)) { 28797c478bd9Sstevel@tonic-gate prf.pr_cur--; 28807c478bd9Sstevel@tonic-gate if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2), 28817c478bd9Sstevel@tonic-gate emsg) == 0) 28827c478bd9Sstevel@tonic-gate overflow = 1; 28837c478bd9Sstevel@tonic-gate } 28847c478bd9Sstevel@tonic-gate } 28857c478bd9Sstevel@tonic-gate 28867c478bd9Sstevel@tonic-gate /* 28877c478bd9Sstevel@tonic-gate * Push out any message that's been built. Note, in the case of an 28887c478bd9Sstevel@tonic-gate * overflow condition, this message may be incomplete, in which case 28897c478bd9Sstevel@tonic-gate * make sure any partial string is null terminated. 28907c478bd9Sstevel@tonic-gate */ 28917c478bd9Sstevel@tonic-gate if ((rtld_flags & (RT_FL_APPLIC | RT_FL_SILENCERR)) == 0) { 28927c478bd9Sstevel@tonic-gate *(prf.pr_cur - 1) = '\n'; 28937c478bd9Sstevel@tonic-gate (void) dowrite(&prf); 28947c478bd9Sstevel@tonic-gate } 289556deab07SRod Evans if (overflow) 289656deab07SRod Evans *(prf.pr_cur - 1) = '\0'; 28977c478bd9Sstevel@tonic-gate 28985aefb655Srie DBG_CALL(Dbg_util_str(lml, nextptr)); 28997c478bd9Sstevel@tonic-gate va_end(args); 29007c478bd9Sstevel@tonic-gate 29017c478bd9Sstevel@tonic-gate /* 29027c478bd9Sstevel@tonic-gate * Determine if there was insufficient space left in the buffer to 29037c478bd9Sstevel@tonic-gate * complete the message. If so, we'll have printed out as much as had 29047c478bd9Sstevel@tonic-gate * been processed if we're not yet executing the application. 29057c478bd9Sstevel@tonic-gate * Otherwise, there will be some debugging diagnostic indicating 29067c478bd9Sstevel@tonic-gate * as much of the error message as possible. Write out a final buffer 29077c478bd9Sstevel@tonic-gate * overflow diagnostic - unlocalized, so we don't chance more errors. 29087c478bd9Sstevel@tonic-gate */ 29097c478bd9Sstevel@tonic-gate if (overflow) { 29107c478bd9Sstevel@tonic-gate char *str = (char *)MSG_INTL(MSG_EMG_BUFOVRFLW); 29117c478bd9Sstevel@tonic-gate 29127c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SILENCERR) == 0) { 29137c478bd9Sstevel@tonic-gate lasterr = str; 29147c478bd9Sstevel@tonic-gate 29157c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_APPLIC) == 0) { 29167c478bd9Sstevel@tonic-gate (void) write(2, str, strlen(str)); 29177c478bd9Sstevel@tonic-gate (void) write(2, MSG_ORIG(MSG_STR_NL), 29187c478bd9Sstevel@tonic-gate MSG_STR_NL_SIZE); 29197c478bd9Sstevel@tonic-gate } 29207c478bd9Sstevel@tonic-gate } 29215aefb655Srie DBG_CALL(Dbg_util_str(lml, str)); 29227c478bd9Sstevel@tonic-gate 29237c478bd9Sstevel@tonic-gate lock = 0; 29247c478bd9Sstevel@tonic-gate nextptr = errbuf + ERRSIZE; 29257c478bd9Sstevel@tonic-gate return; 29267c478bd9Sstevel@tonic-gate } 29277c478bd9Sstevel@tonic-gate 29287c478bd9Sstevel@tonic-gate /* 29297c478bd9Sstevel@tonic-gate * If the application has started, then error messages are being saved 29307c478bd9Sstevel@tonic-gate * for retrieval by dlerror(), or possible flushing from rtldexit() in 29317c478bd9Sstevel@tonic-gate * the case of a fatal error. In this case, establish the next error 29327c478bd9Sstevel@tonic-gate * pointer. If we haven't started the application, the whole message 29337c478bd9Sstevel@tonic-gate * buffer can be reused. 29347c478bd9Sstevel@tonic-gate */ 29357c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SILENCERR) == 0) { 29367c478bd9Sstevel@tonic-gate lasterr = nextptr; 29377c478bd9Sstevel@tonic-gate 29387c478bd9Sstevel@tonic-gate /* 29397c478bd9Sstevel@tonic-gate * Note, should we encounter an error such as ENOMEM, there may 29407c478bd9Sstevel@tonic-gate * be a number of the same error messages (ie. an operation 29417c478bd9Sstevel@tonic-gate * fails with ENOMEM, and then the attempts to construct the 29427c478bd9Sstevel@tonic-gate * error message itself, which incurs additional ENOMEM errors). 29437c478bd9Sstevel@tonic-gate * Compare any previous error message with the one we've just 29447c478bd9Sstevel@tonic-gate * created to prevent any duplication clutter. 29457c478bd9Sstevel@tonic-gate */ 29467c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_APPLIC) && 294743d7826aSRod Evans ((prevptr == NULL) || (strcmp(prevptr, nextptr) != 0))) { 29487c478bd9Sstevel@tonic-gate prevptr = nextptr; 29497c478bd9Sstevel@tonic-gate nextptr = prf.pr_cur; 29507c478bd9Sstevel@tonic-gate *nextptr = '\0'; 29517c478bd9Sstevel@tonic-gate } 29527c478bd9Sstevel@tonic-gate } 29537c478bd9Sstevel@tonic-gate lock = 0; 29547c478bd9Sstevel@tonic-gate } 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate 29577c478bd9Sstevel@tonic-gate #if DEBUG 29587c478bd9Sstevel@tonic-gate /* 295956deab07SRod Evans * Provide assfail() for ASSERT() statements. See <sys/debug.h> for further 296056deab07SRod Evans * details. 29617c478bd9Sstevel@tonic-gate */ 29627c478bd9Sstevel@tonic-gate int 29637c478bd9Sstevel@tonic-gate assfail(const char *a, const char *f, int l) 29647c478bd9Sstevel@tonic-gate { 29657c478bd9Sstevel@tonic-gate (void) printf("assertion failed: %s, file: %s, line: %d\n", a, f, l); 29667c478bd9Sstevel@tonic-gate (void) _lwp_kill(_lwp_self(), SIGABRT); 29677c478bd9Sstevel@tonic-gate return (0); 29687c478bd9Sstevel@tonic-gate } 29697c478bd9Sstevel@tonic-gate #endif 29707c478bd9Sstevel@tonic-gate 29717c478bd9Sstevel@tonic-gate /* 29727c478bd9Sstevel@tonic-gate * Exit. If we arrive here with a non zero status it's because of a fatal 29737c478bd9Sstevel@tonic-gate * error condition (most commonly a relocation error). If the application has 29747c478bd9Sstevel@tonic-gate * already had control, then the actual fatal error message will have been 29757c478bd9Sstevel@tonic-gate * recorded in the dlerror() message buffer. Print the message before really 29767c478bd9Sstevel@tonic-gate * exiting. 29777c478bd9Sstevel@tonic-gate */ 29787c478bd9Sstevel@tonic-gate void 29797c478bd9Sstevel@tonic-gate rtldexit(Lm_list * lml, int status) 29807c478bd9Sstevel@tonic-gate { 29817c478bd9Sstevel@tonic-gate if (status) { 29827c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_APPLIC) { 29837c478bd9Sstevel@tonic-gate /* 29847c478bd9Sstevel@tonic-gate * If the error buffer has been used, write out all 29857c478bd9Sstevel@tonic-gate * pending messages - lasterr is simply a pointer to 29867c478bd9Sstevel@tonic-gate * the last message in this buffer. However, if the 29877c478bd9Sstevel@tonic-gate * buffer couldn't be created at all, lasterr points 29887c478bd9Sstevel@tonic-gate * to a constant error message string. 29897c478bd9Sstevel@tonic-gate */ 29907c478bd9Sstevel@tonic-gate if (*errbuf) { 29917c478bd9Sstevel@tonic-gate char *errptr = errbuf; 29927c478bd9Sstevel@tonic-gate char *errend = errbuf + ERRSIZE; 29937c478bd9Sstevel@tonic-gate 29947c478bd9Sstevel@tonic-gate while ((errptr < errend) && *errptr) { 29957c478bd9Sstevel@tonic-gate size_t size = strlen(errptr); 29967c478bd9Sstevel@tonic-gate (void) write(2, errptr, size); 29977c478bd9Sstevel@tonic-gate (void) write(2, MSG_ORIG(MSG_STR_NL), 29987c478bd9Sstevel@tonic-gate MSG_STR_NL_SIZE); 29997c478bd9Sstevel@tonic-gate errptr += (size + 1); 30007c478bd9Sstevel@tonic-gate } 30017c478bd9Sstevel@tonic-gate } 30027c478bd9Sstevel@tonic-gate if (lasterr && ((lasterr < errbuf) || 30037c478bd9Sstevel@tonic-gate (lasterr > (errbuf + ERRSIZE)))) { 30047c478bd9Sstevel@tonic-gate (void) write(2, lasterr, strlen(lasterr)); 30057c478bd9Sstevel@tonic-gate (void) write(2, MSG_ORIG(MSG_STR_NL), 30067c478bd9Sstevel@tonic-gate MSG_STR_NL_SIZE); 30077c478bd9Sstevel@tonic-gate } 30087c478bd9Sstevel@tonic-gate } 30098cd45542Sraf leave(lml, 0); 30107c478bd9Sstevel@tonic-gate (void) _lwp_kill(_lwp_self(), killsig); 30117c478bd9Sstevel@tonic-gate } 30127c478bd9Sstevel@tonic-gate _exit(status); 30137c478bd9Sstevel@tonic-gate } 30147c478bd9Sstevel@tonic-gate 30157c478bd9Sstevel@tonic-gate /* 301656deab07SRod Evans * Map anonymous memory via MAP_ANON (added in Solaris 8). 30177c478bd9Sstevel@tonic-gate */ 301856deab07SRod Evans void * 30195aefb655Srie dz_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags) 30207c478bd9Sstevel@tonic-gate { 30217c478bd9Sstevel@tonic-gate caddr_t va; 30227c478bd9Sstevel@tonic-gate 302356deab07SRod Evans if ((va = (caddr_t)mmap(addr, len, prot, 302456deab07SRod Evans (flags | MAP_ANON), -1, 0)) == MAP_FAILED) { 302556deab07SRod Evans int err = errno; 302656deab07SRod Evans eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAPANON), 302756deab07SRod Evans strerror(err)); 30287c478bd9Sstevel@tonic-gate return (MAP_FAILED); 30297c478bd9Sstevel@tonic-gate } 30307c478bd9Sstevel@tonic-gate return (va); 30317c478bd9Sstevel@tonic-gate } 30327c478bd9Sstevel@tonic-gate 30337c478bd9Sstevel@tonic-gate static int nu_fd = FD_UNAVAIL; 30347c478bd9Sstevel@tonic-gate 303556deab07SRod Evans void * 30365aefb655Srie nu_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags) 30377c478bd9Sstevel@tonic-gate { 30387c478bd9Sstevel@tonic-gate caddr_t va; 30397c478bd9Sstevel@tonic-gate int err; 30407c478bd9Sstevel@tonic-gate 30417c478bd9Sstevel@tonic-gate if (nu_fd == FD_UNAVAIL) { 30427c478bd9Sstevel@tonic-gate if ((nu_fd = open(MSG_ORIG(MSG_PTH_DEVNULL), 30437c478bd9Sstevel@tonic-gate O_RDONLY)) == FD_UNAVAIL) { 30447c478bd9Sstevel@tonic-gate err = errno; 30455aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), 30467c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_DEVNULL), strerror(err)); 30477c478bd9Sstevel@tonic-gate return (MAP_FAILED); 30487c478bd9Sstevel@tonic-gate } 30497c478bd9Sstevel@tonic-gate } 30507c478bd9Sstevel@tonic-gate 30517c478bd9Sstevel@tonic-gate if ((va = (caddr_t)mmap(addr, len, prot, flags, nu_fd, 0)) == 30527c478bd9Sstevel@tonic-gate MAP_FAILED) { 30537c478bd9Sstevel@tonic-gate err = errno; 30545aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAP), 30557c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_PTH_DEVNULL), strerror(err)); 30567c478bd9Sstevel@tonic-gate } 30577c478bd9Sstevel@tonic-gate return (va); 30587c478bd9Sstevel@tonic-gate } 30597c478bd9Sstevel@tonic-gate 30607c478bd9Sstevel@tonic-gate /* 306175e7992aSrie * Generic entry point from user code - simply grabs a lock, and bumps the 306275e7992aSrie * entrance count. 30637c478bd9Sstevel@tonic-gate */ 30647c478bd9Sstevel@tonic-gate int 30658cd45542Sraf enter(int flags) 30667c478bd9Sstevel@tonic-gate { 30678cd45542Sraf if (rt_bind_guard(THR_FLG_RTLD | thr_flg_nolock | flags)) { 30688cd45542Sraf if (!thr_flg_nolock) 30698cd45542Sraf (void) rt_mutex_lock(&rtldlock); 30702017c965SRod Evans if (rtld_flags & RT_FL_OPERATION) { 30719aa23310Srie ld_entry_cnt++; 30722017c965SRod Evans 30732017c965SRod Evans /* 30742017c965SRod Evans * Reset the diagnostic time information for each new 30752017c965SRod Evans * "operation". Thus timing diagnostics are relative 30762017c965SRod Evans * to entering ld.so.1. 30772017c965SRod Evans */ 30782017c965SRod Evans if (DBG_ISTIME() && 30792017c965SRod Evans (gettimeofday(&DBG_TOTALTIME, NULL) == 0)) { 30802017c965SRod Evans DBG_DELTATIME = DBG_TOTALTIME; 30812017c965SRod Evans DBG_ONRESET(); 30822017c965SRod Evans } 30832017c965SRod Evans } 30847c478bd9Sstevel@tonic-gate return (1); 30857c478bd9Sstevel@tonic-gate } 30867c478bd9Sstevel@tonic-gate return (0); 30877c478bd9Sstevel@tonic-gate } 30887c478bd9Sstevel@tonic-gate 30899aa23310Srie /* 30909aa23310Srie * Determine whether a search path has been used. 30919aa23310Srie */ 30929aa23310Srie static void 309356deab07SRod Evans is_path_used(Lm_list *lml, Word unref, int *nl, Alist *alp, const char *obj) 30949aa23310Srie { 309556deab07SRod Evans Pdesc *pdp; 309656deab07SRod Evans Aliste idx; 309756deab07SRod Evans 309856deab07SRod Evans for (ALIST_TRAVERSE(alp, idx, pdp)) { 30999aa23310Srie const char *fmt, *name; 31009aa23310Srie 310156deab07SRod Evans if ((pdp->pd_plen == 0) || (pdp->pd_flags & PD_FLG_USED)) 31029aa23310Srie continue; 31039aa23310Srie 31049aa23310Srie /* 31059aa23310Srie * If this pathname originated from an expanded token, use the 31069aa23310Srie * original for any diagnostic output. 31079aa23310Srie */ 310856deab07SRod Evans if ((name = pdp->pd_oname) == NULL) 310956deab07SRod Evans name = pdp->pd_pname; 31109aa23310Srie 31119aa23310Srie if (unref == 0) { 31129aa23310Srie if ((*nl)++ == 0) 31139aa23310Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 311456deab07SRod Evans DBG_CALL(Dbg_unused_path(lml, name, pdp->pd_flags, 311556deab07SRod Evans (pdp->pd_flags & PD_FLG_DUPLICAT), obj)); 31169aa23310Srie continue; 31179aa23310Srie } 31189aa23310Srie 311956deab07SRod Evans if (pdp->pd_flags & LA_SER_LIBPATH) { 312056deab07SRod Evans if (pdp->pd_flags & LA_SER_CONFIG) { 312156deab07SRod Evans if (pdp->pd_flags & PD_FLG_DUPLICAT) 31229aa23310Srie fmt = MSG_INTL(MSG_DUP_LDLIBPATHC); 31239aa23310Srie else 31249aa23310Srie fmt = MSG_INTL(MSG_USD_LDLIBPATHC); 31259aa23310Srie } else { 312656deab07SRod Evans if (pdp->pd_flags & PD_FLG_DUPLICAT) 31279aa23310Srie fmt = MSG_INTL(MSG_DUP_LDLIBPATH); 31289aa23310Srie else 31299aa23310Srie fmt = MSG_INTL(MSG_USD_LDLIBPATH); 31309aa23310Srie } 313156deab07SRod Evans } else if (pdp->pd_flags & LA_SER_RUNPATH) { 31329aa23310Srie fmt = MSG_INTL(MSG_USD_RUNPATH); 31339aa23310Srie } else 31349aa23310Srie continue; 31359aa23310Srie 31369aa23310Srie if ((*nl)++ == 0) 31379aa23310Srie (void) printf(MSG_ORIG(MSG_STR_NL)); 31389aa23310Srie (void) printf(fmt, name, obj); 31399aa23310Srie } 31409aa23310Srie } 31419aa23310Srie 31427c478bd9Sstevel@tonic-gate /* 31437c478bd9Sstevel@tonic-gate * Generate diagnostics as to whether an object has been used. A symbolic 31447c478bd9Sstevel@tonic-gate * reference that gets bound to an object marks it as used. Dependencies that 31457c478bd9Sstevel@tonic-gate * are unused when RTLD_NOW is in effect should be removed from future builds 31467c478bd9Sstevel@tonic-gate * of an object. Dependencies that are unused without RTLD_NOW in effect are 31477c478bd9Sstevel@tonic-gate * candidates for lazy-loading. 31489aa23310Srie * 31497c478bd9Sstevel@tonic-gate * Unreferenced objects identify objects that are defined as dependencies but 31509aa23310Srie * are unreferenced by the caller. These unreferenced objects may however be 31519aa23310Srie * referenced by other objects within the process, and therefore don't qualify 31529aa23310Srie * as completely unused. They are still an unnecessary overhead. 31539aa23310Srie * 31549aa23310Srie * Unreferenced runpaths are also captured under ldd -U, or "unused,detail" 31559aa23310Srie * debugging. 31567c478bd9Sstevel@tonic-gate */ 31577c478bd9Sstevel@tonic-gate void 31587c478bd9Sstevel@tonic-gate unused(Lm_list *lml) 31597c478bd9Sstevel@tonic-gate { 31607c478bd9Sstevel@tonic-gate Rt_map *lmp; 31617c478bd9Sstevel@tonic-gate int nl = 0; 31629aa23310Srie Word unref, unuse; 31637c478bd9Sstevel@tonic-gate 31647c478bd9Sstevel@tonic-gate /* 31657c478bd9Sstevel@tonic-gate * If we're not tracing unused references or dependencies, or debugging 31667c478bd9Sstevel@tonic-gate * there's nothing to do. 31677c478bd9Sstevel@tonic-gate */ 31689aa23310Srie unref = lml->lm_flags & LML_FLG_TRC_UNREF; 31699aa23310Srie unuse = lml->lm_flags & LML_FLG_TRC_UNUSED; 31707c478bd9Sstevel@tonic-gate 31719aa23310Srie if ((unref == 0) && (unuse == 0) && (DBG_ENABLED == 0)) 31727c478bd9Sstevel@tonic-gate return; 31737c478bd9Sstevel@tonic-gate 31749aa23310Srie /* 31759aa23310Srie * Detect unused global search paths. 31769aa23310Srie */ 31779aa23310Srie if (rpl_libdirs) 31789aa23310Srie is_path_used(lml, unref, &nl, rpl_libdirs, config->c_name); 31799aa23310Srie if (prm_libdirs) 31809aa23310Srie is_path_used(lml, unref, &nl, prm_libdirs, config->c_name); 31819aa23310Srie 31829aa23310Srie nl = 0; 31839aa23310Srie lmp = lml->lm_head; 31849aa23310Srie if (RLIST(lmp)) 31859aa23310Srie is_path_used(lml, unref, &nl, RLIST(lmp), NAME(lmp)); 31869aa23310Srie 31877c478bd9Sstevel@tonic-gate /* 31887c478bd9Sstevel@tonic-gate * Traverse the link-maps looking for unreferenced or unused 31897c478bd9Sstevel@tonic-gate * dependencies. Ignore the first object on a link-map list, as this 31909aa23310Srie * is always used. 31917c478bd9Sstevel@tonic-gate */ 31929aa23310Srie nl = 0; 3193cb511613SAli Bahrami for (lmp = NEXT_RT_MAP(lmp); lmp; lmp = NEXT_RT_MAP(lmp)) { 31949aa23310Srie /* 31959aa23310Srie * Determine if this object contains any runpaths that have 31969aa23310Srie * not been used. 31979aa23310Srie */ 31989aa23310Srie if (RLIST(lmp)) 31999aa23310Srie is_path_used(lml, unref, &nl, RLIST(lmp), NAME(lmp)); 32009aa23310Srie 32017c478bd9Sstevel@tonic-gate /* 32027c478bd9Sstevel@tonic-gate * If tracing unreferenced objects, or under debugging, 32037c478bd9Sstevel@tonic-gate * determine whether any of this objects callers haven't 32047c478bd9Sstevel@tonic-gate * referenced it. 32057c478bd9Sstevel@tonic-gate */ 32069aa23310Srie if (unref || DBG_ENABLED) { 3207cce0e03bSab Bnd_desc *bdp; 3208cce0e03bSab Aliste idx; 32097c478bd9Sstevel@tonic-gate 3210cce0e03bSab for (APLIST_TRAVERSE(CALLERS(lmp), idx, bdp)) { 32119aa23310Srie Rt_map *clmp; 32127c478bd9Sstevel@tonic-gate 32137c478bd9Sstevel@tonic-gate if (bdp->b_flags & BND_REFER) 32147c478bd9Sstevel@tonic-gate continue; 32157c478bd9Sstevel@tonic-gate 32167c478bd9Sstevel@tonic-gate clmp = bdp->b_caller; 32177c478bd9Sstevel@tonic-gate if (FLAGS1(clmp) & FL1_RT_LDDSTUB) 32187c478bd9Sstevel@tonic-gate continue; 32197c478bd9Sstevel@tonic-gate 3220a953e2b1Srie /* BEGIN CSTYLED */ 32217c478bd9Sstevel@tonic-gate if (nl++ == 0) { 32229aa23310Srie if (unref) 32237c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_STR_NL)); 32247c478bd9Sstevel@tonic-gate else 32255aefb655Srie DBG_CALL(Dbg_util_nl(lml, 32265aefb655Srie DBG_NL_STD)); 32277c478bd9Sstevel@tonic-gate } 32287c478bd9Sstevel@tonic-gate 32299aa23310Srie if (unref) 32307c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_UNREF_FMT), 32317c478bd9Sstevel@tonic-gate NAME(lmp), NAME(clmp)); 32327c478bd9Sstevel@tonic-gate else 32335aefb655Srie DBG_CALL(Dbg_unused_unref(lmp, NAME(clmp))); 3234a953e2b1Srie /* END CSTYLED */ 32357c478bd9Sstevel@tonic-gate } 32367c478bd9Sstevel@tonic-gate } 32377c478bd9Sstevel@tonic-gate 32387c478bd9Sstevel@tonic-gate /* 32397c478bd9Sstevel@tonic-gate * If tracing unused objects simply display those objects that 32407c478bd9Sstevel@tonic-gate * haven't been referenced by anyone. 32417c478bd9Sstevel@tonic-gate */ 32427c478bd9Sstevel@tonic-gate if (FLAGS1(lmp) & FL1_RT_USED) 32437c478bd9Sstevel@tonic-gate continue; 32447c478bd9Sstevel@tonic-gate 32457c478bd9Sstevel@tonic-gate if (nl++ == 0) { 32469aa23310Srie if (unref || unuse) 32477c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_STR_NL)); 32487c478bd9Sstevel@tonic-gate else 32495aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 32507c478bd9Sstevel@tonic-gate } 32517c478bd9Sstevel@tonic-gate if (CYCGROUP(lmp)) { 32529aa23310Srie if (unref || unuse) 32537c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_UNCYC_FMT), 32547c478bd9Sstevel@tonic-gate NAME(lmp), CYCGROUP(lmp)); 32557c478bd9Sstevel@tonic-gate else 32565aefb655Srie DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0, 32577c478bd9Sstevel@tonic-gate CYCGROUP(lmp))); 32587c478bd9Sstevel@tonic-gate } else { 32599aa23310Srie if (unref || unuse) 32607c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_UNUSED_FMT), 32617c478bd9Sstevel@tonic-gate NAME(lmp)); 32627c478bd9Sstevel@tonic-gate else 32635aefb655Srie DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0, 0)); 32647c478bd9Sstevel@tonic-gate } 32657c478bd9Sstevel@tonic-gate } 32667c478bd9Sstevel@tonic-gate 32675aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 32687c478bd9Sstevel@tonic-gate } 32697c478bd9Sstevel@tonic-gate 32707c478bd9Sstevel@tonic-gate /* 32717c478bd9Sstevel@tonic-gate * Generic cleanup routine called prior to returning control to the user. 32727c478bd9Sstevel@tonic-gate * Insures that any ld.so.1 specific file descriptors or temporary mapping are 32737c478bd9Sstevel@tonic-gate * released, and any locks dropped. 32747c478bd9Sstevel@tonic-gate */ 32757c478bd9Sstevel@tonic-gate void 32768cd45542Sraf leave(Lm_list *lml, int flags) 32777c478bd9Sstevel@tonic-gate { 327856deab07SRod Evans Lm_list *elml = lml; 327956deab07SRod Evans Rt_map *clmp; 328056deab07SRod Evans Aliste idx; 328112b8e62eSrie 32827c478bd9Sstevel@tonic-gate /* 328312b8e62eSrie * Alert the debuggers that the link-maps are consistent. Note, in the 328412b8e62eSrie * case of tearing down a whole link-map list, lml will be null. In 328512b8e62eSrie * this case use the main link-map list to test for a notification. 32867c478bd9Sstevel@tonic-gate */ 32873dbfc803SRod Evans if (elml == NULL) 328812b8e62eSrie elml = &lml_main; 328912b8e62eSrie if (elml->lm_flags & LML_FLG_DBNOTIF) 329012b8e62eSrie rd_event(elml, RD_DLACTIVITY, RT_CONSISTENT); 32917c478bd9Sstevel@tonic-gate 32927247f888Srie /* 32937247f888Srie * Alert any auditors that the link-maps are consistent. 32947247f888Srie */ 3295cce0e03bSab for (APLIST_TRAVERSE(elml->lm_actaudit, idx, clmp)) { 3296cce0e03bSab audit_activity(clmp, LA_ACT_CONSISTENT); 32977247f888Srie 3298cce0e03bSab aplist_delete(elml->lm_actaudit, &idx); 32997247f888Srie } 33007247f888Srie 33017c478bd9Sstevel@tonic-gate if (nu_fd != FD_UNAVAIL) { 33027c478bd9Sstevel@tonic-gate (void) close(nu_fd); 33037c478bd9Sstevel@tonic-gate nu_fd = FD_UNAVAIL; 33047c478bd9Sstevel@tonic-gate } 33057c478bd9Sstevel@tonic-gate 33067c478bd9Sstevel@tonic-gate /* 33077c478bd9Sstevel@tonic-gate * Reinitialize error message pointer, and any overflow indication. 33087c478bd9Sstevel@tonic-gate */ 33097c478bd9Sstevel@tonic-gate nextptr = errbuf; 331043d7826aSRod Evans prevptr = NULL; 33117c478bd9Sstevel@tonic-gate 331256deab07SRod Evans /* 331356deab07SRod Evans * Defragment any freed memory. 331456deab07SRod Evans */ 331556deab07SRod Evans if (aplist_nitems(free_alp)) 331656deab07SRod Evans defrag(); 331756deab07SRod Evans 33187c478bd9Sstevel@tonic-gate /* 33197c478bd9Sstevel@tonic-gate * Don't drop our lock if we are running on our link-map list as 33207c478bd9Sstevel@tonic-gate * there's little point in doing so since we are single-threaded. 33217c478bd9Sstevel@tonic-gate * 33227c478bd9Sstevel@tonic-gate * LML_FLG_HOLDLOCK is set for: 332343d7826aSRod Evans * - The ld.so.1's link-map list. 332443d7826aSRod Evans * - The auditor's link-map if the environment is pre-UPM. 33257c478bd9Sstevel@tonic-gate */ 33267c478bd9Sstevel@tonic-gate if (lml && (lml->lm_flags & LML_FLG_HOLDLOCK)) 33277c478bd9Sstevel@tonic-gate return; 33287c478bd9Sstevel@tonic-gate 33297c478bd9Sstevel@tonic-gate if (rt_bind_clear(0) & THR_FLG_RTLD) { 33308cd45542Sraf if (!thr_flg_nolock) 33318cd45542Sraf (void) rt_mutex_unlock(&rtldlock); 33328cd45542Sraf (void) rt_bind_clear(THR_FLG_RTLD | thr_flg_nolock | flags); 33337c478bd9Sstevel@tonic-gate } 33347c478bd9Sstevel@tonic-gate } 33357c478bd9Sstevel@tonic-gate 33367c478bd9Sstevel@tonic-gate int 333760758829Srie callable(Rt_map *clmp, Rt_map *dlmp, Grp_hdl *ghp, uint_t slflags) 33387c478bd9Sstevel@tonic-gate { 3339cce0e03bSab APlist *calp, *dalp; 3340cce0e03bSab Aliste idx1, idx2; 3341cce0e03bSab Grp_hdl *ghp1, *ghp2; 33427c478bd9Sstevel@tonic-gate 33437c478bd9Sstevel@tonic-gate /* 33447c478bd9Sstevel@tonic-gate * An object can always find symbols within itself. 33457c478bd9Sstevel@tonic-gate */ 33467c478bd9Sstevel@tonic-gate if (clmp == dlmp) 33477c478bd9Sstevel@tonic-gate return (1); 33487c478bd9Sstevel@tonic-gate 334960758829Srie /* 335060758829Srie * The search for a singleton must look in every loaded object. 335160758829Srie */ 335260758829Srie if (slflags & LKUP_SINGLETON) 335360758829Srie return (1); 335460758829Srie 33557c478bd9Sstevel@tonic-gate /* 33567c478bd9Sstevel@tonic-gate * Don't allow an object to bind to an object that is being deleted 33577c478bd9Sstevel@tonic-gate * unless the binder is also being deleted. 33587c478bd9Sstevel@tonic-gate */ 33597c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & FLG_RT_DELETE) && 33607c478bd9Sstevel@tonic-gate ((FLAGS(clmp) & FLG_RT_DELETE) == 0)) 33617c478bd9Sstevel@tonic-gate return (0); 33627c478bd9Sstevel@tonic-gate 33637c478bd9Sstevel@tonic-gate /* 33647c478bd9Sstevel@tonic-gate * An object with world access can always bind to an object with global 33657c478bd9Sstevel@tonic-gate * visibility. 33667c478bd9Sstevel@tonic-gate */ 336737ffaf83SRod Evans if (((MODE(clmp) & RTLD_WORLD) || (slflags & LKUP_WORLD)) && 336837ffaf83SRod Evans (MODE(dlmp) & RTLD_GLOBAL)) 33697c478bd9Sstevel@tonic-gate return (1); 33707c478bd9Sstevel@tonic-gate 33717c478bd9Sstevel@tonic-gate /* 33727c478bd9Sstevel@tonic-gate * An object with local access can only bind to an object that is a 33737c478bd9Sstevel@tonic-gate * member of the same group. 33747c478bd9Sstevel@tonic-gate */ 33757c478bd9Sstevel@tonic-gate if (((MODE(clmp) & RTLD_GROUP) == 0) || 3376cce0e03bSab ((calp = GROUPS(clmp)) == NULL) || ((dalp = GROUPS(dlmp)) == NULL)) 33777c478bd9Sstevel@tonic-gate return (0); 33787c478bd9Sstevel@tonic-gate 33797c478bd9Sstevel@tonic-gate /* 33807c478bd9Sstevel@tonic-gate * Traverse the list of groups the caller is a part of. 33817c478bd9Sstevel@tonic-gate */ 3382cce0e03bSab for (APLIST_TRAVERSE(calp, idx1, ghp1)) { 33837c478bd9Sstevel@tonic-gate /* 33847c478bd9Sstevel@tonic-gate * If we're testing for the ability of two objects to bind to 33857c478bd9Sstevel@tonic-gate * each other regardless of a specific group, ignore that group. 33867c478bd9Sstevel@tonic-gate */ 3387cce0e03bSab if (ghp && (ghp1 == ghp)) 33887c478bd9Sstevel@tonic-gate continue; 33897c478bd9Sstevel@tonic-gate 33907c478bd9Sstevel@tonic-gate /* 33917c478bd9Sstevel@tonic-gate * Traverse the list of groups the destination is a part of. 33927c478bd9Sstevel@tonic-gate */ 3393cce0e03bSab for (APLIST_TRAVERSE(dalp, idx2, ghp2)) { 3394efb9e8b8Srie Grp_desc *gdp; 3395cce0e03bSab Aliste idx3; 3396efb9e8b8Srie 3397cce0e03bSab if (ghp1 != ghp2) 3398efb9e8b8Srie continue; 3399efb9e8b8Srie 3400efb9e8b8Srie /* 3401efb9e8b8Srie * Make sure the relationship between the destination 3402efb9e8b8Srie * and the caller provide symbols for relocation. 3403efb9e8b8Srie * Parents are maintained as callers, but unless the 3404efb9e8b8Srie * destination object was opened with RTLD_PARENT, the 3405efb9e8b8Srie * parent doesn't provide symbols for the destination 3406efb9e8b8Srie * to relocate against. 3407efb9e8b8Srie */ 3408cce0e03bSab for (ALIST_TRAVERSE(ghp2->gh_depends, idx3, gdp)) { 3409efb9e8b8Srie if (dlmp != gdp->gd_depend) 3410efb9e8b8Srie continue; 3411efb9e8b8Srie 3412efb9e8b8Srie if (gdp->gd_flags & GPD_RELOC) 3413efb9e8b8Srie return (1); 3414efb9e8b8Srie } 34157c478bd9Sstevel@tonic-gate } 34167c478bd9Sstevel@tonic-gate } 34177c478bd9Sstevel@tonic-gate return (0); 34187c478bd9Sstevel@tonic-gate } 34197c478bd9Sstevel@tonic-gate 34207c478bd9Sstevel@tonic-gate /* 34217c478bd9Sstevel@tonic-gate * Initialize the environ symbol. Traditionally this is carried out by the crt 34227c478bd9Sstevel@tonic-gate * code prior to jumping to main. However, init sections get fired before this 34237c478bd9Sstevel@tonic-gate * variable is initialized, so ld.so.1 sets this directly from the AUX vector 34247c478bd9Sstevel@tonic-gate * information. In addition, a process may have multiple link-maps (ld.so.1's 34257c478bd9Sstevel@tonic-gate * debugging and preloading objects), and link auditing, and each may need an 34267c478bd9Sstevel@tonic-gate * environ variable set. 34277c478bd9Sstevel@tonic-gate * 34287c478bd9Sstevel@tonic-gate * This routine is called after a relocation() pass, and thus provides for: 34297c478bd9Sstevel@tonic-gate * 343043d7826aSRod Evans * - setting environ on the main link-map after the initial application and 34317c478bd9Sstevel@tonic-gate * its dependencies have been established. Typically environ lives in the 34327c478bd9Sstevel@tonic-gate * application (provided by its crt), but in older applications it might 34337c478bd9Sstevel@tonic-gate * be in libc. Who knows what's expected of applications not built on 34347c478bd9Sstevel@tonic-gate * Solaris. 34357c478bd9Sstevel@tonic-gate * 343643d7826aSRod Evans * - after loading a new shared object. We can add shared objects to various 34377c478bd9Sstevel@tonic-gate * link-maps, and any link-map dependencies requiring getopt() require 34387c478bd9Sstevel@tonic-gate * their own environ. In addition, lazy loading might bring in the 343941072f3cSrie * supplier of environ (libc used to be a lazy loading candidate) after 344041072f3cSrie * the link-map has been established and other objects are present. 34417c478bd9Sstevel@tonic-gate * 34427c478bd9Sstevel@tonic-gate * This routine handles all these scenarios, without adding unnecessary overhead 34437c478bd9Sstevel@tonic-gate * to ld.so.1. 34447c478bd9Sstevel@tonic-gate */ 34457c478bd9Sstevel@tonic-gate void 34467c478bd9Sstevel@tonic-gate set_environ(Lm_list *lml) 34477c478bd9Sstevel@tonic-gate { 34487c478bd9Sstevel@tonic-gate Slookup sl; 3449*08278a5eSRod Evans Sresult sr; 34507c478bd9Sstevel@tonic-gate uint_t binfo; 34517c478bd9Sstevel@tonic-gate 345275e7992aSrie /* 3453*08278a5eSRod Evans * Initialize the symbol lookup, and symbol result, data structures. 345475e7992aSrie */ 345575e7992aSrie SLOOKUP_INIT(sl, MSG_ORIG(MSG_SYM_ENVIRON), lml->lm_head, lml->lm_head, 345675e7992aSrie ld_entry_cnt, 0, 0, 0, 0, LKUP_WEAK); 3457*08278a5eSRod Evans SRESULT_INIT(sr, MSG_ORIG(MSG_SYM_ENVIRON)); 3458*08278a5eSRod Evans 3459*08278a5eSRod Evans if (LM_LOOKUP_SYM(lml->lm_head)(&sl, &sr, &binfo, 0)) { 3460*08278a5eSRod Evans Rt_map *dlmp = sr.sr_dmap; 34617c478bd9Sstevel@tonic-gate 3462*08278a5eSRod Evans lml->lm_environ = (char ***)sr.sr_sym->st_value; 34637c478bd9Sstevel@tonic-gate 34647c478bd9Sstevel@tonic-gate if (!(FLAGS(dlmp) & FLG_RT_FIXED)) 346541072f3cSrie lml->lm_environ = 346641072f3cSrie (char ***)((uintptr_t)lml->lm_environ + 346741072f3cSrie (uintptr_t)ADDR(dlmp)); 346841072f3cSrie *(lml->lm_environ) = (char **)environ; 34697c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_ENVIRON; 34707c478bd9Sstevel@tonic-gate } 34717c478bd9Sstevel@tonic-gate } 34727c478bd9Sstevel@tonic-gate 34737c478bd9Sstevel@tonic-gate /* 34747c478bd9Sstevel@tonic-gate * Determine whether we have a secure executable. Uid and gid information 34757c478bd9Sstevel@tonic-gate * can be passed to us via the aux vector, however if these values are -1 34767c478bd9Sstevel@tonic-gate * then use the appropriate system call to obtain them. 34777c478bd9Sstevel@tonic-gate * 347843d7826aSRod Evans * - If the user is the root they can do anything 34797c478bd9Sstevel@tonic-gate * 348043d7826aSRod Evans * - If the real and effective uid's don't match, or the real and 34817c478bd9Sstevel@tonic-gate * effective gid's don't match then this is determined to be a `secure' 34827c478bd9Sstevel@tonic-gate * application. 34837c478bd9Sstevel@tonic-gate * 34847c478bd9Sstevel@tonic-gate * This function is called prior to any dependency processing (see _setup.c). 34857c478bd9Sstevel@tonic-gate * Any secure setting will remain in effect for the life of the process. 34867c478bd9Sstevel@tonic-gate */ 34877c478bd9Sstevel@tonic-gate void 34887c478bd9Sstevel@tonic-gate security(uid_t uid, uid_t euid, gid_t gid, gid_t egid, int auxflags) 34897c478bd9Sstevel@tonic-gate { 34907c478bd9Sstevel@tonic-gate if (auxflags != -1) { 34917c478bd9Sstevel@tonic-gate if ((auxflags & AF_SUN_SETUGID) != 0) 34927c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_SECURE; 34937c478bd9Sstevel@tonic-gate return; 34947c478bd9Sstevel@tonic-gate } 349556deab07SRod Evans 3496a953e2b1Srie if (uid == (uid_t)-1) 34977c478bd9Sstevel@tonic-gate uid = getuid(); 34987c478bd9Sstevel@tonic-gate if (uid) { 3499a953e2b1Srie if (euid == (uid_t)-1) 35007c478bd9Sstevel@tonic-gate euid = geteuid(); 35017c478bd9Sstevel@tonic-gate if (uid != euid) 35027c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_SECURE; 35037c478bd9Sstevel@tonic-gate else { 3504a953e2b1Srie if (gid == (gid_t)-1) 35057c478bd9Sstevel@tonic-gate gid = getgid(); 3506a953e2b1Srie if (egid == (gid_t)-1) 35077c478bd9Sstevel@tonic-gate egid = getegid(); 35087c478bd9Sstevel@tonic-gate if (gid != egid) 35097c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_SECURE; 35107c478bd9Sstevel@tonic-gate } 35117c478bd9Sstevel@tonic-gate } 35127c478bd9Sstevel@tonic-gate } 35137c478bd9Sstevel@tonic-gate 35143dbfc803SRod Evans /* 35153dbfc803SRod Evans * Determine whether ld.so.1 itself is owned by root and has its mode setuid. 35163dbfc803SRod Evans */ 35173dbfc803SRod Evans int 35183dbfc803SRod Evans is_rtld_setuid() 35193dbfc803SRod Evans { 3520cb511613SAli Bahrami rtld_stat_t status; 35213dbfc803SRod Evans 35223dbfc803SRod Evans if ((rtld_flags2 & RT_FL2_SETUID) || 3523cb511613SAli Bahrami ((rtld_stat(NAME(lml_rtld.lm_head), &status) == 0) && 35243dbfc803SRod Evans (status.st_uid == 0) && (status.st_mode & S_ISUID))) { 35253dbfc803SRod Evans rtld_flags2 |= RT_FL2_SETUID; 35263dbfc803SRod Evans return (1); 35273dbfc803SRod Evans } 35283dbfc803SRod Evans return (0); 35293dbfc803SRod Evans } 35303dbfc803SRod Evans 3531*08278a5eSRod Evans /* 3532*08278a5eSRod Evans * Determine that systems platform name. Normally, this name is provided from 3533*08278a5eSRod Evans * the AT_SUN_PLATFORM aux vector from the kernel. This routine provides a 3534*08278a5eSRod Evans * fall back. 3535*08278a5eSRod Evans */ 3536*08278a5eSRod Evans void 3537*08278a5eSRod Evans platform_name(Syscapset *scapset) 3538*08278a5eSRod Evans { 3539*08278a5eSRod Evans char info[SYS_NMLN]; 3540*08278a5eSRod Evans size_t size; 3541*08278a5eSRod Evans 3542*08278a5eSRod Evans if ((scapset->sc_platsz = size = 3543*08278a5eSRod Evans sysinfo(SI_PLATFORM, info, SYS_NMLN)) == (size_t)-1) 3544*08278a5eSRod Evans return; 3545*08278a5eSRod Evans 3546*08278a5eSRod Evans if ((scapset->sc_plat = malloc(size)) == NULL) { 3547*08278a5eSRod Evans scapset->sc_platsz = (size_t)-1; 3548*08278a5eSRod Evans return; 3549*08278a5eSRod Evans } 3550*08278a5eSRod Evans (void) strcpy(scapset->sc_plat, info); 3551*08278a5eSRod Evans } 3552*08278a5eSRod Evans 3553*08278a5eSRod Evans /* 3554*08278a5eSRod Evans * Determine that systems machine name. Normally, this name is provided from 3555*08278a5eSRod Evans * the AT_SUN_MACHINE aux vector from the kernel. This routine provides a 3556*08278a5eSRod Evans * fall back. 3557*08278a5eSRod Evans */ 3558*08278a5eSRod Evans void 3559*08278a5eSRod Evans machine_name(Syscapset *scapset) 3560*08278a5eSRod Evans { 3561*08278a5eSRod Evans char info[SYS_NMLN]; 3562*08278a5eSRod Evans size_t size; 3563*08278a5eSRod Evans 3564*08278a5eSRod Evans if ((scapset->sc_machsz = size = 3565*08278a5eSRod Evans sysinfo(SI_MACHINE, info, SYS_NMLN)) == (size_t)-1) 3566*08278a5eSRod Evans return; 3567*08278a5eSRod Evans 3568*08278a5eSRod Evans if ((scapset->sc_mach = malloc(size)) == NULL) { 3569*08278a5eSRod Evans scapset->sc_machsz = (size_t)-1; 3570*08278a5eSRod Evans return; 3571*08278a5eSRod Evans } 3572*08278a5eSRod Evans (void) strcpy(scapset->sc_mach, info); 3573*08278a5eSRod Evans } 3574*08278a5eSRod Evans 35757c478bd9Sstevel@tonic-gate /* 35767c478bd9Sstevel@tonic-gate * _REENTRANT code gets errno redefined to a function so provide for return 35777c478bd9Sstevel@tonic-gate * of the thread errno if applicable. This has no meaning in ld.so.1 which 35787c478bd9Sstevel@tonic-gate * is basically singled threaded. Provide the interface for our dependencies. 35797c478bd9Sstevel@tonic-gate */ 35807c478bd9Sstevel@tonic-gate #undef errno 35817c478bd9Sstevel@tonic-gate int * 35827c478bd9Sstevel@tonic-gate ___errno() 35837c478bd9Sstevel@tonic-gate { 35847c478bd9Sstevel@tonic-gate extern int errno; 35857c478bd9Sstevel@tonic-gate 35867c478bd9Sstevel@tonic-gate return (&errno); 35877c478bd9Sstevel@tonic-gate } 35887c478bd9Sstevel@tonic-gate 35897c478bd9Sstevel@tonic-gate /* 35907c478bd9Sstevel@tonic-gate * Determine whether a symbol name should be demangled. 35917c478bd9Sstevel@tonic-gate */ 35927c478bd9Sstevel@tonic-gate const char * 35937c478bd9Sstevel@tonic-gate demangle(const char *name) 35947c478bd9Sstevel@tonic-gate { 35957c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_DEMANGLE) 35965aefb655Srie return (conv_demangle_name(name)); 35977c478bd9Sstevel@tonic-gate else 35987c478bd9Sstevel@tonic-gate return (name); 35997c478bd9Sstevel@tonic-gate } 3600cb511613SAli Bahrami 3601cb511613SAli Bahrami #ifndef _LP64 3602cb511613SAli Bahrami /* 3603cb511613SAli Bahrami * Wrappers on stat() and fstat() for 32-bit rtld that uses stat64() 3604cb511613SAli Bahrami * underneath while preserving the object size limits of a non-largefile 3605cb511613SAli Bahrami * enabled 32-bit process. The purpose of this is to prevent large inode 3606cb511613SAli Bahrami * values from causing stat() to fail. 3607cb511613SAli Bahrami */ 3608cb511613SAli Bahrami inline static int 3609cb511613SAli Bahrami rtld_stat_process(int r, struct stat64 *lbuf, rtld_stat_t *restrict buf) 3610cb511613SAli Bahrami { 3611cb511613SAli Bahrami extern int errno; 3612cb511613SAli Bahrami 3613cb511613SAli Bahrami /* 3614cb511613SAli Bahrami * Although we used a 64-bit capable stat(), the 32-bit rtld 3615cb511613SAli Bahrami * can only handle objects < 2GB in size. If this object is 3616cb511613SAli Bahrami * too big, turn the success into an overflow error. 3617cb511613SAli Bahrami */ 3618cb511613SAli Bahrami if ((lbuf->st_size & 0xffffffff80000000) != 0) { 3619cb511613SAli Bahrami errno = EOVERFLOW; 3620cb511613SAli Bahrami return (-1); 3621cb511613SAli Bahrami } 3622cb511613SAli Bahrami 3623cb511613SAli Bahrami /* 3624cb511613SAli Bahrami * Transfer the information needed by rtld into a rtld_stat_t 3625cb511613SAli Bahrami * structure that preserves the non-largile types for everything 3626cb511613SAli Bahrami * except inode. 3627cb511613SAli Bahrami */ 3628cb511613SAli Bahrami buf->st_dev = lbuf->st_dev; 3629cb511613SAli Bahrami buf->st_ino = lbuf->st_ino; 3630cb511613SAli Bahrami buf->st_mode = lbuf->st_mode; 3631cb511613SAli Bahrami buf->st_uid = lbuf->st_uid; 3632cb511613SAli Bahrami buf->st_size = (off_t)lbuf->st_size; 3633cb511613SAli Bahrami buf->st_mtim = lbuf->st_mtim; 3634cb511613SAli Bahrami #ifdef sparc 3635cb511613SAli Bahrami buf->st_blksize = lbuf->st_blksize; 3636cb511613SAli Bahrami #endif 3637cb511613SAli Bahrami 3638cb511613SAli Bahrami return (r); 3639cb511613SAli Bahrami } 3640cb511613SAli Bahrami 3641cb511613SAli Bahrami int 3642cb511613SAli Bahrami rtld_stat(const char *restrict path, rtld_stat_t *restrict buf) 3643cb511613SAli Bahrami { 3644cb511613SAli Bahrami struct stat64 lbuf; 3645cb511613SAli Bahrami int r; 3646cb511613SAli Bahrami 3647cb511613SAli Bahrami r = stat64(path, &lbuf); 3648cb511613SAli Bahrami if (r != -1) 3649cb511613SAli Bahrami r = rtld_stat_process(r, &lbuf, buf); 3650cb511613SAli Bahrami return (r); 3651cb511613SAli Bahrami } 3652cb511613SAli Bahrami 3653cb511613SAli Bahrami int 3654cb511613SAli Bahrami rtld_fstat(int fildes, rtld_stat_t *restrict buf) 3655cb511613SAli Bahrami { 3656cb511613SAli Bahrami struct stat64 lbuf; 3657cb511613SAli Bahrami int r; 3658cb511613SAli Bahrami 3659cb511613SAli Bahrami r = fstat64(fildes, &lbuf); 3660cb511613SAli Bahrami if (r != -1) 3661cb511613SAli Bahrami r = rtld_stat_process(r, &lbuf, buf); 3662cb511613SAli Bahrami return (r); 3663cb511613SAli Bahrami } 3664cb511613SAli Bahrami #endif 3665