xref: /illumos-gate/usr/src/cmd/sgs/rtld/common/analyze.c (revision 80422caf)
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 /*
23f441771bSRod Evans  * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267257d1b4Sraf /*
277257d1b4Sraf  *	Copyright (c) 1988 AT&T
287257d1b4Sraf  *	  All Rights Reserved
297257d1b4Sraf  */
307257d1b4Sraf 
317c478bd9Sstevel@tonic-gate #include	<string.h>
327c478bd9Sstevel@tonic-gate #include	<stdio.h>
337c478bd9Sstevel@tonic-gate #include	<unistd.h>
347c478bd9Sstevel@tonic-gate #include	<sys/stat.h>
357c478bd9Sstevel@tonic-gate #include	<sys/mman.h>
3656deab07SRod Evans #include	<sys/debug.h>
377c478bd9Sstevel@tonic-gate #include	<fcntl.h>
387c478bd9Sstevel@tonic-gate #include	<limits.h>
397c478bd9Sstevel@tonic-gate #include	<dlfcn.h>
407c478bd9Sstevel@tonic-gate #include	<errno.h>
417c478bd9Sstevel@tonic-gate #include	<link.h>
425aefb655Srie #include	<debug.h>
435aefb655Srie #include	<conv.h>
447c478bd9Sstevel@tonic-gate #include	"_rtld.h"
457c478bd9Sstevel@tonic-gate #include	"_audit.h"
467c478bd9Sstevel@tonic-gate #include	"_elf.h"
47f441771bSRod Evans #include	"_inline_gen.h"
487c478bd9Sstevel@tonic-gate #include	"msg.h"
497c478bd9Sstevel@tonic-gate 
507c478bd9Sstevel@tonic-gate /*
517c478bd9Sstevel@tonic-gate  * If a load filter flag is in effect, and this object is a filter, trigger the
527c478bd9Sstevel@tonic-gate  * loading of all its filtees.  The load filter flag is in effect when creating
537c478bd9Sstevel@tonic-gate  * configuration files, or when under the control of ldd(1), or the LD_LOADFLTR
547c478bd9Sstevel@tonic-gate  * environment variable is set, or this object was built with the -zloadfltr
557c478bd9Sstevel@tonic-gate  * flag.  Otherwise, filtee loading is deferred until triggered by a relocation.
567c478bd9Sstevel@tonic-gate  */
577c478bd9Sstevel@tonic-gate static void
load_filtees(Rt_map * lmp,int * in_nfavl)589aa23310Srie load_filtees(Rt_map *lmp, int *in_nfavl)
597c478bd9Sstevel@tonic-gate {
607c478bd9Sstevel@tonic-gate 	if ((FLAGS1(lmp) & MSK_RT_FILTER) &&
617c478bd9Sstevel@tonic-gate 	    ((FLAGS(lmp) & FLG_RT_LOADFLTR) ||
627c478bd9Sstevel@tonic-gate 	    (LIST(lmp)->lm_tflags & LML_TFLG_LOADFLTR))) {
6375e7992aSrie 		Dyninfo		*dip =  DYNINFO(lmp);
647c478bd9Sstevel@tonic-gate 		uint_t		cnt, max = DYNINFOCNT(lmp);
657c478bd9Sstevel@tonic-gate 		Slookup		sl;
667c478bd9Sstevel@tonic-gate 
6775e7992aSrie 		/*
6808278a5eSRod Evans 		 * Initialize the symbol lookup data structure.  Note, no symbol
6908278a5eSRod Evans 		 * name is supplied.  This NULL name causes filters to be loaded
7008278a5eSRod Evans 		 * but no symbol to be searched for.
7175e7992aSrie 		 */
7275e7992aSrie 		SLOOKUP_INIT(sl, 0, lmp, lmp, ld_entry_cnt, 0, 0, 0, 0, 0);
737c478bd9Sstevel@tonic-gate 
747c478bd9Sstevel@tonic-gate 		for (cnt = 0; cnt < max; cnt++, dip++) {
7508278a5eSRod Evans 			uint_t	binfo;
7608278a5eSRod Evans 			Sresult	sr;
7708278a5eSRod Evans 
7808278a5eSRod Evans 			SRESULT_INIT(sr, NULL);
7908278a5eSRod Evans 
807c478bd9Sstevel@tonic-gate 			if (((dip->di_flags & MSK_DI_FILTER) == 0) ||
817c478bd9Sstevel@tonic-gate 			    ((dip->di_flags & FLG_DI_AUXFLTR) &&
827c478bd9Sstevel@tonic-gate 			    (rtld_flags & RT_FL_NOAUXFLTR)))
837c478bd9Sstevel@tonic-gate 				continue;
8408278a5eSRod Evans 			(void) elf_lookup_filtee(&sl, &sr, &binfo, cnt,
8508278a5eSRod Evans 			    in_nfavl);
867c478bd9Sstevel@tonic-gate 		}
877c478bd9Sstevel@tonic-gate 	}
887c478bd9Sstevel@tonic-gate }
897c478bd9Sstevel@tonic-gate 
907c478bd9Sstevel@tonic-gate /*
917c478bd9Sstevel@tonic-gate  * Analyze one or more link-maps of a link map control list.  This routine is
927c478bd9Sstevel@tonic-gate  * called at startup to continue the processing of the main executable.  It is
937c478bd9Sstevel@tonic-gate  * also called each time a new set of objects are loaded, ie. from filters,
947c478bd9Sstevel@tonic-gate  * lazy-loaded objects, or dlopen().
957c478bd9Sstevel@tonic-gate  *
967c478bd9Sstevel@tonic-gate  * In each instance we traverse the link-map control list starting with the
977c478bd9Sstevel@tonic-gate  * initial object.  As dependencies are analyzed they are added to the link-map
987c478bd9Sstevel@tonic-gate  * control list.  Thus the list grows as we traverse it - this results in the
997c478bd9Sstevel@tonic-gate  * breadth first ordering of all needed objects.
10056deab07SRod Evans  *
10156deab07SRod Evans  * Return the initial link-map from which analysis starts for relocate_lmc().
1027c478bd9Sstevel@tonic-gate  */
10356deab07SRod Evans Rt_map *
analyze_lmc(Lm_list * lml,Aliste nlmco,Rt_map * nlmp,Rt_map * clmp,int * in_nfavl)1042020b2b6SRod Evans analyze_lmc(Lm_list *lml, Aliste nlmco, Rt_map *nlmp, Rt_map *clmp,
1052020b2b6SRod Evans     int *in_nfavl)
1067c478bd9Sstevel@tonic-gate {
10756deab07SRod Evans 	Rt_map	*lmp;
1087c478bd9Sstevel@tonic-gate 	Lm_cntl	*nlmc;
1097c478bd9Sstevel@tonic-gate 
1107c478bd9Sstevel@tonic-gate 	/*
1117c478bd9Sstevel@tonic-gate 	 * If this link-map control list is being analyzed, return.  The object
1127c478bd9Sstevel@tonic-gate 	 * that has just been added will be picked up by the existing analysis
1137c478bd9Sstevel@tonic-gate 	 * thread.  Note, this is only really meaningful during process init-
1147c478bd9Sstevel@tonic-gate 	 * ialization, as objects are added to the main link-map control list.
1157c478bd9Sstevel@tonic-gate 	 * Following this initialization, each family of objects that are loaded
1167c478bd9Sstevel@tonic-gate 	 * are added to a new link-map control list.
1177c478bd9Sstevel@tonic-gate 	 */
1187c478bd9Sstevel@tonic-gate 	/* LINTED */
119cce0e03bSab 	nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco);
1207c478bd9Sstevel@tonic-gate 	if (nlmc->lc_flags & LMC_FLG_ANALYZING)
12156deab07SRod Evans 		return (nlmp);
1227c478bd9Sstevel@tonic-gate 
1237c478bd9Sstevel@tonic-gate 	/*
1247c478bd9Sstevel@tonic-gate 	 * If this object doesn't belong to the present link-map control list
1257c478bd9Sstevel@tonic-gate 	 * then it must already have been analyzed, or it is in the process of
1267c478bd9Sstevel@tonic-gate 	 * being analyzed prior to us recursing into this analysis.  In either
1277c478bd9Sstevel@tonic-gate 	 * case, ignore the object as it's already being taken care of.
1287c478bd9Sstevel@tonic-gate 	 */
1297c478bd9Sstevel@tonic-gate 	if (nlmco != CNTL(nlmp))
13056deab07SRod Evans 		return (nlmp);
1317c478bd9Sstevel@tonic-gate 
1327c478bd9Sstevel@tonic-gate 	nlmc->lc_flags |= LMC_FLG_ANALYZING;
1337c478bd9Sstevel@tonic-gate 
13456deab07SRod Evans 	for (lmp = nlmp; lmp; lmp = NEXT_RT_MAP(lmp)) {
1357c478bd9Sstevel@tonic-gate 		if (FLAGS(lmp) &
1367c478bd9Sstevel@tonic-gate 		    (FLG_RT_ANALZING | FLG_RT_ANALYZED | FLG_RT_DELETE))
1377c478bd9Sstevel@tonic-gate 			continue;
1387c478bd9Sstevel@tonic-gate 
1397c478bd9Sstevel@tonic-gate 		/*
1407c478bd9Sstevel@tonic-gate 		 * Indicate that analyzing is under way.
1417c478bd9Sstevel@tonic-gate 		 */
1427c478bd9Sstevel@tonic-gate 		FLAGS(lmp) |= FLG_RT_ANALZING;
1437c478bd9Sstevel@tonic-gate 
1447c478bd9Sstevel@tonic-gate 		/*
1457c478bd9Sstevel@tonic-gate 		 * If this link map represents a relocatable object, then we
1467c478bd9Sstevel@tonic-gate 		 * need to finish the link-editing of the object at this point.
1477c478bd9Sstevel@tonic-gate 		 */
1487c478bd9Sstevel@tonic-gate 		if (FLAGS(lmp) & FLG_RT_OBJECT) {
14956deab07SRod Evans 			Rt_map	*olmp;
15056deab07SRod Evans 
1512020b2b6SRod Evans 			if ((olmp = elf_obj_fini(lml, lmp, clmp,
1522020b2b6SRod Evans 			    in_nfavl)) == NULL) {
1537c478bd9Sstevel@tonic-gate 				if (lml->lm_flags & LML_FLG_TRC_ENABLE)
1547c478bd9Sstevel@tonic-gate 					continue;
15556deab07SRod Evans 				nlmp = NULL;
1567c478bd9Sstevel@tonic-gate 				break;
1577c478bd9Sstevel@tonic-gate 			}
15856deab07SRod Evans 
15956deab07SRod Evans 			/*
16056deab07SRod Evans 			 * The original link-map that captured a relocatable
16156deab07SRod Evans 			 * object is a temporary link-map, that basically acts
16256deab07SRod Evans 			 * as a place holder in the link-map list.  On
16356deab07SRod Evans 			 * completion of relocatable object processing, a new
16456deab07SRod Evans 			 * link-map is created, and switched with the place
16556deab07SRod Evans 			 * holder.  Therefore, reassign both the present
16656deab07SRod Evans 			 * link-map pointer and the return link-map pointer.
16756deab07SRod Evans 			 * The former resets this routines link-map processing,
16856deab07SRod Evans 			 * while the latter provides for later functions, like
16956deab07SRod Evans 			 * relocate_lmc(), to start processing from this new
17056deab07SRod Evans 			 * link-map.
17156deab07SRod Evans 			 */
17256deab07SRod Evans 			if (nlmp == lmp)
17356deab07SRod Evans 				nlmp = olmp;
17456deab07SRod Evans 			lmp = olmp;
1757c478bd9Sstevel@tonic-gate 		}
1767c478bd9Sstevel@tonic-gate 
1777c478bd9Sstevel@tonic-gate 		DBG_CALL(Dbg_file_analyze(lmp));
1787c478bd9Sstevel@tonic-gate 
1797c478bd9Sstevel@tonic-gate 		/*
1807c478bd9Sstevel@tonic-gate 		 * Establish any dependencies this object requires.
1817c478bd9Sstevel@tonic-gate 		 */
1829aa23310Srie 		if (LM_NEEDED(lmp)(lml, nlmco, lmp, in_nfavl) == 0) {
1837c478bd9Sstevel@tonic-gate 			if (lml->lm_flags & LML_FLG_TRC_ENABLE)
1847c478bd9Sstevel@tonic-gate 				continue;
18556deab07SRod Evans 			nlmp = NULL;
1867c478bd9Sstevel@tonic-gate 			break;
1877c478bd9Sstevel@tonic-gate 		}
1887c478bd9Sstevel@tonic-gate 
1897c478bd9Sstevel@tonic-gate 		FLAGS(lmp) &= ~FLG_RT_ANALZING;
1907c478bd9Sstevel@tonic-gate 		FLAGS(lmp) |= FLG_RT_ANALYZED;
1917c478bd9Sstevel@tonic-gate 
1927c478bd9Sstevel@tonic-gate 		/*
1937c478bd9Sstevel@tonic-gate 		 * If we're building a configuration file, determine if this
1947c478bd9Sstevel@tonic-gate 		 * object is a filter and if so load its filtees.  This
1957c478bd9Sstevel@tonic-gate 		 * traversal is only necessary for crle(1), as typical use of
1967c478bd9Sstevel@tonic-gate 		 * an object will load filters as part of relocation processing.
1977c478bd9Sstevel@tonic-gate 		 */
1987c478bd9Sstevel@tonic-gate 		if (MODE(nlmp) & RTLD_CONFGEN)
1999aa23310Srie 			load_filtees(lmp, in_nfavl);
2007c478bd9Sstevel@tonic-gate 
2017c478bd9Sstevel@tonic-gate 		/*
2027c478bd9Sstevel@tonic-gate 		 * If an interposer has been added, it will have been inserted
2037c478bd9Sstevel@tonic-gate 		 * in the link-map before the link we're presently analyzing.
2047c478bd9Sstevel@tonic-gate 		 * Break out of this analysis loop and return to the head of
2057c478bd9Sstevel@tonic-gate 		 * the link-map control list to analyze the interposer.  Note
2067c478bd9Sstevel@tonic-gate 		 * that this rescan preserves the breadth first loading of
2077c478bd9Sstevel@tonic-gate 		 * dependencies.
2087c478bd9Sstevel@tonic-gate 		 */
20924a6229eSrie 		/* LINTED */
210cce0e03bSab 		nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco);
2117c478bd9Sstevel@tonic-gate 		if (nlmc->lc_flags & LMC_FLG_REANALYZE) {
2127c478bd9Sstevel@tonic-gate 			nlmc->lc_flags &= ~LMC_FLG_REANALYZE;
2137c478bd9Sstevel@tonic-gate 			lmp = nlmc->lc_head;
2147c478bd9Sstevel@tonic-gate 		}
2157c478bd9Sstevel@tonic-gate 	}
2167c478bd9Sstevel@tonic-gate 
21724a6229eSrie 	/* LINTED */
218cce0e03bSab 	nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco);
2197c478bd9Sstevel@tonic-gate 	nlmc->lc_flags &= ~LMC_FLG_ANALYZING;
2207c478bd9Sstevel@tonic-gate 
22156deab07SRod Evans 	return (nlmp);
2227c478bd9Sstevel@tonic-gate }
2237c478bd9Sstevel@tonic-gate 
2247c478bd9Sstevel@tonic-gate /*
225466e2a62Srie  * Determine whether a symbol represents zero, .bss, bits.  Most commonly this
226466e2a62Srie  * function is used to determine whether the data for a copy relocation refers
227466e2a62Srie  * to initialized data or .bss.  If the data definition is within .bss, then the
228466e2a62Srie  * data is zero filled, and as the copy destination within the executable is
229466e2a62Srie  * .bss, we can skip copying zero's to zero's.
230466e2a62Srie  *
231466e2a62Srie  * However, if the defining object has MOVE data, it's .bss might contain
232466e2a62Srie  * non-zero data, in which case copy the definition regardless.
233466e2a62Srie  *
234466e2a62Srie  * For backward compatibility copy relocation processing, this routine can be
235466e2a62Srie  * used to determine precisely if a copy destination is a move record recipient.
2367c478bd9Sstevel@tonic-gate  */
2377c478bd9Sstevel@tonic-gate static int
are_bits_zero(Rt_map * dlmp,Sym * dsym,int dest)238466e2a62Srie are_bits_zero(Rt_map *dlmp, Sym *dsym, int dest)
2397c478bd9Sstevel@tonic-gate {
24056deab07SRod Evans 	mmapobj_result_t	*mpp;
24156deab07SRod Evans 	caddr_t			daddr = (caddr_t)dsym->st_value;
2427c478bd9Sstevel@tonic-gate 
243466e2a62Srie 	if ((FLAGS(dlmp) & FLG_RT_FIXED) == 0)
244466e2a62Srie 		daddr += ADDR(dlmp);
2457c478bd9Sstevel@tonic-gate 
246466e2a62Srie 	/*
247466e2a62Srie 	 * Determine the segment that contains the copy definition.  Given that
248466e2a62Srie 	 * the copy relocation records have already been captured and verified,
249466e2a62Srie 	 * a segment must be found (but we add an escape clause never the less).
250466e2a62Srie 	 */
25156deab07SRod Evans 	if ((mpp = find_segment(daddr, dlmp)) == NULL)
252466e2a62Srie 		return (1);
253466e2a62Srie 
254466e2a62Srie 	/*
255466e2a62Srie 	 * If the definition is not within .bss, indicate this is not zero data.
256466e2a62Srie 	 */
25756deab07SRod Evans 	if (daddr < (mpp->mr_addr + mpp->mr_offset + mpp->mr_fsize))
258466e2a62Srie 		return (0);
259466e2a62Srie 
260466e2a62Srie 	/*
261466e2a62Srie 	 * If the definition is within .bss, make sure the definition isn't the
262466e2a62Srie 	 * recipient of a move record.  Note, we don't precisely analyze whether
263466e2a62Srie 	 * the address is a move record recipient, as the infrastructure to
264466e2a62Srie 	 * prepare for, and carry out this analysis, is probably more costly
265466e2a62Srie 	 * than just copying the bytes regardless.
266466e2a62Srie 	 */
267466e2a62Srie 	if ((FLAGS(dlmp) & FLG_RT_MOVE) == 0)
268466e2a62Srie 		return (1);
269466e2a62Srie 
270466e2a62Srie 	/*
271466e2a62Srie 	 * However, for backward compatibility copy relocation processing, we
272466e2a62Srie 	 * can afford to work a little harder.  Here, determine precisely
273466e2a62Srie 	 * whether the destination in the executable is a move record recipient.
274466e2a62Srie 	 * See comments in lookup_sym_interpose(), below.
275466e2a62Srie 	 */
276466e2a62Srie 	if (dest && is_move_data(daddr))
277466e2a62Srie 		return (0);
278466e2a62Srie 
279466e2a62Srie 	return (1);
2807c478bd9Sstevel@tonic-gate }
2817c478bd9Sstevel@tonic-gate 
2827c478bd9Sstevel@tonic-gate /*
2837c478bd9Sstevel@tonic-gate  * Relocate an individual object.
2847c478bd9Sstevel@tonic-gate  */
2857c478bd9Sstevel@tonic-gate static int
relocate_so(Lm_list * lml,Rt_map * lmp,int * relocated,int now,int * in_nfavl)2869aa23310Srie relocate_so(Lm_list *lml, Rt_map *lmp, int *relocated, int now, int *in_nfavl)
2877c478bd9Sstevel@tonic-gate {
28856deab07SRod Evans 	APlist	*textrel = NULL;
28956deab07SRod Evans 	int	ret = 1;
29056deab07SRod Evans 
2917c478bd9Sstevel@tonic-gate 	/*
2927c478bd9Sstevel@tonic-gate 	 * If we're running under ldd(1), and haven't been asked to trace any
2937c478bd9Sstevel@tonic-gate 	 * warnings, skip any actual relocation processing.
2947c478bd9Sstevel@tonic-gate 	 */
2957c478bd9Sstevel@tonic-gate 	if (((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0) ||
2967c478bd9Sstevel@tonic-gate 	    (lml->lm_flags & LML_FLG_TRC_WARN)) {
2977c478bd9Sstevel@tonic-gate 
2987c478bd9Sstevel@tonic-gate 		if (relocated)
2997c478bd9Sstevel@tonic-gate 			(*relocated)++;
3007c478bd9Sstevel@tonic-gate 
30156deab07SRod Evans 		if ((LM_RELOC(lmp)(lmp, now, in_nfavl, &textrel) == 0) &&
3027c478bd9Sstevel@tonic-gate 		    ((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0))
30356deab07SRod Evans 			ret = 0;
30456deab07SRod Evans 
30556deab07SRod Evans 		/*
30656deab07SRod Evans 		 * Finally process any move data.  Note, this is carried out
30756deab07SRod Evans 		 * with ldd(1) under relocation processing too, as it can flush
30856deab07SRod Evans 		 * out move errors, and enables lari(1) to provide a true
30956deab07SRod Evans 		 * representation of the runtime bindings.
31056deab07SRod Evans 		 */
31156deab07SRod Evans 		if ((FLAGS(lmp) & FLG_RT_MOVE) &&
31256deab07SRod Evans 		    (move_data(lmp, &textrel) == 0) &&
31356deab07SRod Evans 		    ((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0))
31456deab07SRod Evans 			ret = 0;
3157c478bd9Sstevel@tonic-gate 	}
31656deab07SRod Evans 
31756deab07SRod Evans 	/*
31856deab07SRod Evans 	 * If a text segment was write enabled to perform any relocations or
31956deab07SRod Evans 	 * move records, then re-protect the segment by disabling writes.
32056deab07SRod Evans 	 */
32156deab07SRod Evans 	if (textrel) {
32256deab07SRod Evans 		mmapobj_result_t	*mpp;
32356deab07SRod Evans 		Aliste			idx;
32456deab07SRod Evans 
32556deab07SRod Evans 		for (APLIST_TRAVERSE(textrel, idx, mpp))
32656deab07SRod Evans 			(void) set_prot(lmp, mpp, 0);
32756deab07SRod Evans 		free(textrel);
32856deab07SRod Evans 	}
32956deab07SRod Evans 
33056deab07SRod Evans 	return (ret);
3317c478bd9Sstevel@tonic-gate }
3327c478bd9Sstevel@tonic-gate 
3337c478bd9Sstevel@tonic-gate /*
3347c478bd9Sstevel@tonic-gate  * Relocate the objects on a link-map control list.
3357c478bd9Sstevel@tonic-gate  */
3367c478bd9Sstevel@tonic-gate static int
_relocate_lmc(Lm_list * lml,Aliste lmco,Rt_map * nlmp,int * relocated,int * in_nfavl)33756deab07SRod Evans _relocate_lmc(Lm_list *lml, Aliste lmco, Rt_map *nlmp, int *relocated,
33856deab07SRod Evans     int *in_nfavl)
3397c478bd9Sstevel@tonic-gate {
3407c478bd9Sstevel@tonic-gate 	Rt_map	*lmp;
3417c478bd9Sstevel@tonic-gate 
342cb511613SAli Bahrami 	for (lmp = nlmp; lmp; lmp = NEXT_RT_MAP(lmp)) {
3437c478bd9Sstevel@tonic-gate 		/*
3447c478bd9Sstevel@tonic-gate 		 * If this object has already been relocated, we're done.  If
3457c478bd9Sstevel@tonic-gate 		 * this object is being deleted, skip it, there's probably a
3467c478bd9Sstevel@tonic-gate 		 * relocation error somewhere that's causing this deletion.
3477c478bd9Sstevel@tonic-gate 		 */
3487c478bd9Sstevel@tonic-gate 		if (FLAGS(lmp) &
3497c478bd9Sstevel@tonic-gate 		    (FLG_RT_RELOCING | FLG_RT_RELOCED | FLG_RT_DELETE))
3507c478bd9Sstevel@tonic-gate 			continue;
3517c478bd9Sstevel@tonic-gate 
3527c478bd9Sstevel@tonic-gate 		/*
3537c478bd9Sstevel@tonic-gate 		 * Indicate that relocation processing is under way.
3547c478bd9Sstevel@tonic-gate 		 */
3557c478bd9Sstevel@tonic-gate 		FLAGS(lmp) |= FLG_RT_RELOCING;
3567c478bd9Sstevel@tonic-gate 
3577c478bd9Sstevel@tonic-gate 		/*
3587c478bd9Sstevel@tonic-gate 		 * Relocate the object.
3597c478bd9Sstevel@tonic-gate 		 */
3609aa23310Srie 		if (relocate_so(lml, lmp, relocated, 0, in_nfavl) == 0)
3617c478bd9Sstevel@tonic-gate 			return (0);
3627c478bd9Sstevel@tonic-gate 
3637c478bd9Sstevel@tonic-gate 		/*
3647c478bd9Sstevel@tonic-gate 		 * Indicate that the objects relocation is complete.
3657c478bd9Sstevel@tonic-gate 		 */
3667c478bd9Sstevel@tonic-gate 		FLAGS(lmp) &= ~FLG_RT_RELOCING;
3677c478bd9Sstevel@tonic-gate 		FLAGS(lmp) |= FLG_RT_RELOCED;
3687c478bd9Sstevel@tonic-gate 
3697c478bd9Sstevel@tonic-gate 		/*
37056deab07SRod Evans 		 * If this object is being relocated on the main link-map list
37156deab07SRod Evans 		 * indicate that this object's init is available for harvesting.
37256deab07SRod Evans 		 * Objects that are being collected on other link-map lists
37356deab07SRod Evans 		 * will have there init availability tagged when the objects
37456deab07SRod Evans 		 * are move to the main link-map list (ie, after we know they,
37556deab07SRod Evans 		 * and their dependencies, are fully relocated and ready for
37656deab07SRod Evans 		 * use).
37756deab07SRod Evans 		 *
37856deab07SRod Evans 		 * Note, even under ldd(1) this init identification is necessary
37956deab07SRod Evans 		 * for -i (tsort) gathering.
3807c478bd9Sstevel@tonic-gate 		 */
38156deab07SRod Evans 		if (lmco == ALIST_OFF_DATA) {
38256deab07SRod Evans 			lml->lm_init++;
38356deab07SRod Evans 			lml->lm_flags |= LML_FLG_OBJADDED;
384466e2a62Srie 		}
3857c478bd9Sstevel@tonic-gate 
3867c478bd9Sstevel@tonic-gate 		/*
3877c478bd9Sstevel@tonic-gate 		 * Determine if this object is a filter, and if a load filter
3887c478bd9Sstevel@tonic-gate 		 * flag is in effect, trigger the loading of all its filtees.
3897c478bd9Sstevel@tonic-gate 		 */
3909aa23310Srie 		load_filtees(lmp, in_nfavl);
3917c478bd9Sstevel@tonic-gate 	}
3927c478bd9Sstevel@tonic-gate 
3937c478bd9Sstevel@tonic-gate 	/*
3947c478bd9Sstevel@tonic-gate 	 * Perform special copy relocations.  These are only meaningful for
3957c478bd9Sstevel@tonic-gate 	 * dynamic executables (fixed and head of their link-map list).  If
3967c478bd9Sstevel@tonic-gate 	 * this ever has to change then the infrastructure of COPY() has to
397cce0e03bSab 	 * change. Presently, a given link map can only have a receiver or
398cce0e03bSab 	 * supplier of copy data, so a union is used to overlap the storage
399cce0e03bSab 	 * for the COPY_R() and COPY_S() lists. These lists would need to
400cce0e03bSab 	 * be separated.
4017c478bd9Sstevel@tonic-gate 	 */
4027c478bd9Sstevel@tonic-gate 	if ((FLAGS(nlmp) & FLG_RT_FIXED) && (nlmp == LIST(nlmp)->lm_head) &&
4037c478bd9Sstevel@tonic-gate 	    (((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0) ||
4047c478bd9Sstevel@tonic-gate 	    (lml->lm_flags & LML_FLG_TRC_WARN))) {
405cce0e03bSab 		Rt_map		*lmp;
406cce0e03bSab 		Aliste		idx1;
4077c478bd9Sstevel@tonic-gate 		Word		tracing;
4087c478bd9Sstevel@tonic-gate 
40902ca3e02Srie #if	defined(__i386)
4107c478bd9Sstevel@tonic-gate 		if (elf_copy_gen(nlmp) == 0)
4117c478bd9Sstevel@tonic-gate 			return (0);
4127c478bd9Sstevel@tonic-gate #endif
413cce0e03bSab 		if (COPY_S(nlmp) == NULL)
4147c478bd9Sstevel@tonic-gate 			return (1);
4157c478bd9Sstevel@tonic-gate 
4167c478bd9Sstevel@tonic-gate 		if ((LIST(nlmp)->lm_flags & LML_FLG_TRC_ENABLE) &&
4177c478bd9Sstevel@tonic-gate 		    (((rtld_flags & RT_FL_SILENCERR) == 0) ||
4187c478bd9Sstevel@tonic-gate 		    (LIST(nlmp)->lm_flags & LML_FLG_TRC_VERBOSE)))
4197c478bd9Sstevel@tonic-gate 			tracing = 1;
4207c478bd9Sstevel@tonic-gate 		else
4217c478bd9Sstevel@tonic-gate 			tracing = 0;
4227c478bd9Sstevel@tonic-gate 
4235aefb655Srie 		DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
4247c478bd9Sstevel@tonic-gate 
425cce0e03bSab 		for (APLIST_TRAVERSE(COPY_S(nlmp), idx1, lmp)) {
426aa736cbeSrie 			Rel_copy	*rcp;
427cce0e03bSab 			Aliste		idx2;
4287c478bd9Sstevel@tonic-gate 
429cce0e03bSab 			for (ALIST_TRAVERSE(COPY_R(lmp), idx2, rcp)) {
4307c478bd9Sstevel@tonic-gate 				int zero;
4317c478bd9Sstevel@tonic-gate 
4327c478bd9Sstevel@tonic-gate 				/*
433466e2a62Srie 				 * Only copy the data if the data is from
434466e2a62Srie 				 * a non-zero definition (ie. not .bss).
4357c478bd9Sstevel@tonic-gate 				 */
436466e2a62Srie 				zero = are_bits_zero(rcp->r_dlmp,
437466e2a62Srie 				    rcp->r_dsym, 0);
4385aefb655Srie 				DBG_CALL(Dbg_reloc_copy(rcp->r_dlmp, nlmp,
4395aefb655Srie 				    rcp->r_name, zero));
4407c478bd9Sstevel@tonic-gate 				if (zero)
4417c478bd9Sstevel@tonic-gate 					continue;
4427c478bd9Sstevel@tonic-gate 
4437c478bd9Sstevel@tonic-gate 				(void) memcpy(rcp->r_radd, rcp->r_dadd,
4447c478bd9Sstevel@tonic-gate 				    rcp->r_size);
4457c478bd9Sstevel@tonic-gate 
4467c478bd9Sstevel@tonic-gate 				if ((tracing == 0) || ((FLAGS1(rcp->r_dlmp) &
4477c478bd9Sstevel@tonic-gate 				    FL1_RT_DISPREL) == 0))
4487c478bd9Sstevel@tonic-gate 					continue;
4497c478bd9Sstevel@tonic-gate 
4507c478bd9Sstevel@tonic-gate 				(void) printf(MSG_INTL(MSG_LDD_REL_CPYDISP),
4517c478bd9Sstevel@tonic-gate 				    demangle(rcp->r_name), NAME(rcp->r_dlmp));
4527c478bd9Sstevel@tonic-gate 			}
4537c478bd9Sstevel@tonic-gate 		}
4547c478bd9Sstevel@tonic-gate 
4555aefb655Srie 		DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
4567c478bd9Sstevel@tonic-gate 
457cce0e03bSab 		free(COPY_S(nlmp));
4582017c965SRod Evans 		COPY_S(nlmp) = NULL;
4597c478bd9Sstevel@tonic-gate 	}
4607c478bd9Sstevel@tonic-gate 	return (1);
4617c478bd9Sstevel@tonic-gate }
4627c478bd9Sstevel@tonic-gate 
4637c478bd9Sstevel@tonic-gate int
relocate_lmc(Lm_list * lml,Aliste nlmco,Rt_map * clmp,Rt_map * nlmp,int * in_nfavl)4649aa23310Srie relocate_lmc(Lm_list *lml, Aliste nlmco, Rt_map *clmp, Rt_map *nlmp,
4659aa23310Srie     int *in_nfavl)
4667c478bd9Sstevel@tonic-gate {
4677c478bd9Sstevel@tonic-gate 	int	lret = 1, pret = 1;
468cce0e03bSab 	APlist	*alp;
4697c478bd9Sstevel@tonic-gate 	Aliste	plmco;
4707c478bd9Sstevel@tonic-gate 	Lm_cntl	*plmc, *nlmc;
4717c478bd9Sstevel@tonic-gate 
4727c478bd9Sstevel@tonic-gate 	/*
4737c478bd9Sstevel@tonic-gate 	 * If this link-map control list is being relocated, return.  The object
4747c478bd9Sstevel@tonic-gate 	 * that has just been added will be picked up by the existing relocation
4757c478bd9Sstevel@tonic-gate 	 * thread.  Note, this is only really meaningful during process init-
4767c478bd9Sstevel@tonic-gate 	 * ialization, as objects are added to the main link-map control list.
4777c478bd9Sstevel@tonic-gate 	 * Following this initialization, each family of objects that are loaded
4787c478bd9Sstevel@tonic-gate 	 * are added to a new link-map control list.
4797c478bd9Sstevel@tonic-gate 	 */
4807c478bd9Sstevel@tonic-gate 	/* LINTED */
481cce0e03bSab 	nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco);
4827c478bd9Sstevel@tonic-gate 
4837c478bd9Sstevel@tonic-gate 	if (nlmc->lc_flags & LMC_FLG_RELOCATING)
4847c478bd9Sstevel@tonic-gate 		return (1);
4857c478bd9Sstevel@tonic-gate 
4867c478bd9Sstevel@tonic-gate 	nlmc->lc_flags |= LMC_FLG_RELOCATING;
4877c478bd9Sstevel@tonic-gate 
4887c478bd9Sstevel@tonic-gate 	/*
4897c478bd9Sstevel@tonic-gate 	 * Relocate one or more link-maps of a link map control list.  If this
4907c478bd9Sstevel@tonic-gate 	 * object doesn't belong to the present link-map control list then it
4917c478bd9Sstevel@tonic-gate 	 * must already have been relocated, or it is in the process of being
4927c478bd9Sstevel@tonic-gate 	 * relocated prior to us recursing into this relocation.  In either
4937c478bd9Sstevel@tonic-gate 	 * case, ignore the object as it's already being taken care of, however,
4947c478bd9Sstevel@tonic-gate 	 * fall through and capture any relocation promotions that might have
4957c478bd9Sstevel@tonic-gate 	 * been established from the reference mode of this object.
4967c478bd9Sstevel@tonic-gate 	 *
4977c478bd9Sstevel@tonic-gate 	 * If we're generating a configuration file using crle(1), two passes
4987c478bd9Sstevel@tonic-gate 	 * may be involved.  Under the first pass, RTLD_CONFGEN is set.  Under
4997c478bd9Sstevel@tonic-gate 	 * this pass, crle() loads objects into the process address space.  No
5007c478bd9Sstevel@tonic-gate 	 * relocation is necessary at this point, we simply need to analyze the
50108278a5eSRod Evans 	 * objects to ensure any directly bound dependencies, filtees, etc.
50208278a5eSRod Evans 	 * get loaded.  Although we skip the relocation, fall through to ensure
5037c478bd9Sstevel@tonic-gate 	 * any control lists are maintained appropriately.
5047c478bd9Sstevel@tonic-gate 	 *
5057c478bd9Sstevel@tonic-gate 	 * If objects are to be dldump(3c)'ed, crle(1) makes a second pass,
5067c478bd9Sstevel@tonic-gate 	 * using RTLD_NOW and RTLD_CONFGEN.  The RTLD_NOW effectively carries
5077c478bd9Sstevel@tonic-gate 	 * out the relocations of all loaded objects.
5087c478bd9Sstevel@tonic-gate 	 */
5097c478bd9Sstevel@tonic-gate 	if ((nlmco == CNTL(nlmp)) &&
5107c478bd9Sstevel@tonic-gate 	    ((MODE(nlmp) & (RTLD_NOW | RTLD_CONFGEN)) != RTLD_CONFGEN)) {
5117c478bd9Sstevel@tonic-gate 		int	relocated = 0;
5127c478bd9Sstevel@tonic-gate 
5137c478bd9Sstevel@tonic-gate 		/*
5147c478bd9Sstevel@tonic-gate 		 * Determine whether the initial link-map control list has
5157c478bd9Sstevel@tonic-gate 		 * started relocation.  From this point, should any interposing
5167c478bd9Sstevel@tonic-gate 		 * objects be added to this link-map control list, the objects
5177c478bd9Sstevel@tonic-gate 		 * are demoted to standard objects.  Their interposition can't
5187c478bd9Sstevel@tonic-gate 		 * be guaranteed once relocations have been carried out.
5197c478bd9Sstevel@tonic-gate 		 */
520cce0e03bSab 		if (nlmco == ALIST_OFF_DATA)
5217c478bd9Sstevel@tonic-gate 			lml->lm_flags |= LML_FLG_STARTREL;
5227c478bd9Sstevel@tonic-gate 
5237c478bd9Sstevel@tonic-gate 		/*
52402ca3e02Srie 		 * Relocate the link-map control list.  Should this relocation
52502ca3e02Srie 		 * fail, clean up this link-map list.  Relocations within this
52602ca3e02Srie 		 * list may have required relocation promotions on other lists,
52702ca3e02Srie 		 * so before acting upon these, and possibly adding more objects
52802ca3e02Srie 		 * to the present link-map control list, try and clean up any
52902ca3e02Srie 		 * failed objects now.
5307c478bd9Sstevel@tonic-gate 		 */
53156deab07SRod Evans 		lret = _relocate_lmc(lml, nlmco, nlmp, &relocated, in_nfavl);
532cce0e03bSab 		if ((lret == 0) && (nlmco != ALIST_OFF_DATA))
533481bba9eSRod Evans 			remove_lmc(lml, clmp, nlmco, NAME(nlmp));
5347c478bd9Sstevel@tonic-gate 	}
5357c478bd9Sstevel@tonic-gate 
5367c478bd9Sstevel@tonic-gate 	/*
5377c478bd9Sstevel@tonic-gate 	 * Determine the new, and previous link-map control lists.
5387c478bd9Sstevel@tonic-gate 	 */
53924a6229eSrie 	/* LINTED */
540cce0e03bSab 	nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco);
541cce0e03bSab 	if (nlmco == ALIST_OFF_DATA) {
5426679fdc0Srie 		plmco = nlmco;
5437c478bd9Sstevel@tonic-gate 		plmc = nlmc;
5446679fdc0Srie 	} else {
5457c478bd9Sstevel@tonic-gate 		plmco = nlmco - lml->lm_lists->al_size;
5467c478bd9Sstevel@tonic-gate 		/* LINTED */
547cce0e03bSab 		plmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, plmco);
5487c478bd9Sstevel@tonic-gate 	}
5497c478bd9Sstevel@tonic-gate 
5507c478bd9Sstevel@tonic-gate 	/*
5517c478bd9Sstevel@tonic-gate 	 * Having completed this control list of objects, they can now be bound
5527c478bd9Sstevel@tonic-gate 	 * to from other objects.  Move this control list to the control list
5537c478bd9Sstevel@tonic-gate 	 * that precedes it.  Although this control list may have only bound to
5547c478bd9Sstevel@tonic-gate 	 * controls lists much higher up the control list stack, it must only
5557c478bd9Sstevel@tonic-gate 	 * be moved up one control list so as to preserve the link-map order
5567c478bd9Sstevel@tonic-gate 	 * that may have already been traversed in search of symbols.
5577c478bd9Sstevel@tonic-gate 	 */
558cce0e03bSab 	if (lret && (nlmco != ALIST_OFF_DATA) && nlmc->lc_head)
5597c478bd9Sstevel@tonic-gate 		lm_move(lml, nlmco, plmco, nlmc, plmc);
5607c478bd9Sstevel@tonic-gate 
5617c478bd9Sstevel@tonic-gate 	/*
5627c478bd9Sstevel@tonic-gate 	 * Determine whether existing objects that have already been relocated,
5637c478bd9Sstevel@tonic-gate 	 * need any additional relocations performed.  This can occur when new
5647c478bd9Sstevel@tonic-gate 	 * objects are loaded with RTLD_NOW, and these new objects have
5657c478bd9Sstevel@tonic-gate 	 * dependencies on objects that are already loaded.  Note, that we peel
5667c478bd9Sstevel@tonic-gate 	 * any relocation promotions off of one control list at a time.  This
5677c478bd9Sstevel@tonic-gate 	 * prevents relocations from being bound to objects that might yet fail
5687c478bd9Sstevel@tonic-gate 	 * to relocate themselves.
5697c478bd9Sstevel@tonic-gate 	 */
570cce0e03bSab 	while ((alp = plmc->lc_now) != NULL) {
571cce0e03bSab 		Aliste	idx;
572cce0e03bSab 		Rt_map	*lmp;
5737c478bd9Sstevel@tonic-gate 
5747c478bd9Sstevel@tonic-gate 		/*
5757c478bd9Sstevel@tonic-gate 		 * Remove the relocation promotion list, as performing more
5767c478bd9Sstevel@tonic-gate 		 * relocations may result in discovering more objects that need
5777c478bd9Sstevel@tonic-gate 		 * promotion.
5787c478bd9Sstevel@tonic-gate 		 */
579cce0e03bSab 		plmc->lc_now = NULL;
5807c478bd9Sstevel@tonic-gate 
581cce0e03bSab 		for (APLIST_TRAVERSE(alp, idx, lmp)) {
5827c478bd9Sstevel@tonic-gate 			/*
5837c478bd9Sstevel@tonic-gate 			 * If the original relocation of the link-map control
5847c478bd9Sstevel@tonic-gate 			 * list failed, or one of the relocation promotions of
5857c478bd9Sstevel@tonic-gate 			 * this loop has failed, demote any pending objects
5867c478bd9Sstevel@tonic-gate 			 * relocation mode.
5877c478bd9Sstevel@tonic-gate 			 */
5887c478bd9Sstevel@tonic-gate 			if ((lret == 0) || (pret == 0)) {
5897c478bd9Sstevel@tonic-gate 				MODE(lmp) &= ~RTLD_NOW;
5907c478bd9Sstevel@tonic-gate 				MODE(lmp) |= RTLD_LAZY;
5917c478bd9Sstevel@tonic-gate 				continue;
5927c478bd9Sstevel@tonic-gate 			}
5937c478bd9Sstevel@tonic-gate 
5947c478bd9Sstevel@tonic-gate 			/*
5957c478bd9Sstevel@tonic-gate 			 * If a relocation fails, save the error condition.
5967c478bd9Sstevel@tonic-gate 			 * It's possible that all new objects on the original
5977c478bd9Sstevel@tonic-gate 			 * link-map control list have been relocated
5987c478bd9Sstevel@tonic-gate 			 * successfully, but if the user request requires
5997c478bd9Sstevel@tonic-gate 			 * promoting objects that have already been loaded, we
6007c478bd9Sstevel@tonic-gate 			 * have to indicate that this operation couldn't be
6017c478bd9Sstevel@tonic-gate 			 * performed.  The unrelocated objects are in use on
6027c478bd9Sstevel@tonic-gate 			 * another control list, and may continue to be used.
6037c478bd9Sstevel@tonic-gate 			 * If the .plt that resulted in the error is called,
6047c478bd9Sstevel@tonic-gate 			 * then the process will receive a fatal error at that
6057c478bd9Sstevel@tonic-gate 			 * time.  But, the .plt may never be called.
6067c478bd9Sstevel@tonic-gate 			 */
6079aa23310Srie 			if (relocate_so(lml, lmp, 0, 1, in_nfavl) == 0)
6087c478bd9Sstevel@tonic-gate 				pret = 0;
6097c478bd9Sstevel@tonic-gate 		}
6107c478bd9Sstevel@tonic-gate 
6117c478bd9Sstevel@tonic-gate 		/*
6127c478bd9Sstevel@tonic-gate 		 * Having promoted any objects, determine whether additional
6137c478bd9Sstevel@tonic-gate 		 * dependencies were added, and if so move them to the previous
6147c478bd9Sstevel@tonic-gate 		 * link-map control list.
6157c478bd9Sstevel@tonic-gate 		 */
61624a6229eSrie 		/* LINTED */
617cce0e03bSab 		nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco);
61824a6229eSrie 		/* LINTED */
619cce0e03bSab 		plmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, plmco);
620cce0e03bSab 		if ((nlmco != ALIST_OFF_DATA) && nlmc->lc_head)
6217c478bd9Sstevel@tonic-gate 			lm_move(lml, nlmco, plmco, nlmc, plmc);
6228521e5e6Srie 		free(alp);
6237c478bd9Sstevel@tonic-gate 	}
6247c478bd9Sstevel@tonic-gate 
62524a6229eSrie 	/*
62602ca3e02Srie 	 * If relocations have been successful, indicate that relocations are
62702ca3e02Srie 	 * no longer active for this control list.  Otherwise, leave the
62802ca3e02Srie 	 * relocation flag, as this flag is used to determine the style of
62902ca3e02Srie 	 * cleanup (see remove_lmc()).
63024a6229eSrie 	 */
63102ca3e02Srie 	if (lret && pret) {
63202ca3e02Srie 		/* LINTED */
633cce0e03bSab 		nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco);
63402ca3e02Srie 		nlmc->lc_flags &= ~LMC_FLG_RELOCATING;
6357c478bd9Sstevel@tonic-gate 
6367c478bd9Sstevel@tonic-gate 		return (1);
63702ca3e02Srie 	}
63802ca3e02Srie 
63902ca3e02Srie 	return (0);
6407c478bd9Sstevel@tonic-gate }
6417c478bd9Sstevel@tonic-gate 
6427c478bd9Sstevel@tonic-gate /*
6437c478bd9Sstevel@tonic-gate  * Inherit the first rejection message for possible later diagnostics.
6447c478bd9Sstevel@tonic-gate  *
6457c478bd9Sstevel@tonic-gate  * Any attempt to process a file that is unsuccessful, should be accompanied
6467c478bd9Sstevel@tonic-gate  * with an error diagnostic.  However, some operations like searching for a
6477c478bd9Sstevel@tonic-gate  * simple filename, involve trying numerous paths, and an error message for each
6487c478bd9Sstevel@tonic-gate  * lookup is not required.  Although a multiple search can fail, it's possible
6497c478bd9Sstevel@tonic-gate  * that a file was found, but was rejected because it was the wrong type.
6507c478bd9Sstevel@tonic-gate  * To satisfy these possibilities, the first failure is recorded as a rejection
6517c478bd9Sstevel@tonic-gate  * message, and this message is used later for a more specific diagnostic.
6527c478bd9Sstevel@tonic-gate  *
6537c478bd9Sstevel@tonic-gate  * File searches are focused at load_one(), and from here a rejection descriptor
6547c478bd9Sstevel@tonic-gate  * is passed down to various child routines.  If these child routines can
6557c478bd9Sstevel@tonic-gate  * process multiple files, then they will maintain their own rejection desc-
6567c478bd9Sstevel@tonic-gate  * riptor.  This is filled in for any failures, and a diagnostic produced to
6577c478bd9Sstevel@tonic-gate  * reflect the failure.  The child routines then employ rejection_inherit() to
6587c478bd9Sstevel@tonic-gate  * pass the first rejection message back to load_one().
6597c478bd9Sstevel@tonic-gate  *
6607c478bd9Sstevel@tonic-gate  * Note that the name, and rejection string must be duplicated, as the name
6617c478bd9Sstevel@tonic-gate  * buffer and error string buffer (see conv_ routines) may be reused for
6627c478bd9Sstevel@tonic-gate  * additional processing or rejection messages.
6637c478bd9Sstevel@tonic-gate  */
6647c478bd9Sstevel@tonic-gate void
rejection_inherit(Rej_desc * rej1,Rej_desc * rej2)66531fdd7caSab rejection_inherit(Rej_desc *rej1, Rej_desc *rej2)
6667c478bd9Sstevel@tonic-gate {
6677c478bd9Sstevel@tonic-gate 	if (rej2->rej_type && (rej1->rej_type == 0)) {
6687c478bd9Sstevel@tonic-gate 		rej1->rej_type = rej2->rej_type;
6697c478bd9Sstevel@tonic-gate 		rej1->rej_info = rej2->rej_info;
67056deab07SRod Evans 		rej1->rej_flags = rej2->rej_flags;
6717c478bd9Sstevel@tonic-gate 		if (rej2->rej_name)
67256deab07SRod Evans 			rej1->rej_name = stravl_insert(rej2->rej_name, 0, 0, 0);
67356deab07SRod Evans 		if ((rej2->rej_str) && ((rej1->rej_str =
67456deab07SRod Evans 		    stravl_insert(rej2->rej_str, 0, 0, 0)) == NULL))
67556deab07SRod Evans 			rej1->rej_str = MSG_ORIG(MSG_EMG_ENOMEM);
6767c478bd9Sstevel@tonic-gate 	}
6777c478bd9Sstevel@tonic-gate }
6787c478bd9Sstevel@tonic-gate 
6797c478bd9Sstevel@tonic-gate /*
6800aa3cd4dSrie  * Helper routine for is_so_matched() that consolidates matching a path name,
6810aa3cd4dSrie  * or file name component of a link-map name.
6827c478bd9Sstevel@tonic-gate  */
68356deab07SRod Evans inline static int
_is_so_matched(const char * name,const char * str,int path)6840aa3cd4dSrie _is_so_matched(const char *name, const char *str, int path)
6857c478bd9Sstevel@tonic-gate {
6867c478bd9Sstevel@tonic-gate 	const char	*_str;
6877c478bd9Sstevel@tonic-gate 
6880aa3cd4dSrie 	if ((path == 0) && ((_str = strrchr(str, '/')) != NULL))
6897c478bd9Sstevel@tonic-gate 		_str++;
6907c478bd9Sstevel@tonic-gate 	else
6917c478bd9Sstevel@tonic-gate 		_str = str;
6927c478bd9Sstevel@tonic-gate 
6937c478bd9Sstevel@tonic-gate 	return (strcmp(name, _str));
6947c478bd9Sstevel@tonic-gate }
6957c478bd9Sstevel@tonic-gate 
6960aa3cd4dSrie /*
6970aa3cd4dSrie  * Determine whether a search name matches one of the names associated with a
6980aa3cd4dSrie  * link-map.  A link-map contains several names:
6990aa3cd4dSrie  *
7002017c965SRod Evans  *  -	a NAME() - this is the basename of the dynamic executable that started
7012017c965SRod Evans  *	the process, and the path name of any dependencies used by the process.
7022017c965SRod Evans  *	Most executables are received as full path names, as exec() prepends a
7032017c965SRod Evans  *	search $PATH to locate the executable.  However, simple file names can
7042017c965SRod Evans  *	be received from exec() if the file is executed from the present working
7052017c965SRod Evans  *	directory.  Regardless, ld.so.1 maintains NAME() as the basename, as
7062017c965SRod Evans  *	this has always been the name used in diagnostics and error messages.
7072017c965SRod Evans  *	Most dependencies are full path names, as the typical search for a
7082017c965SRod Evans  *	dependency, say "libx.so.1", results in search paths being prepended to
7092017c965SRod Evans  *	the name, which eventually open "/lib/libx.so.1".  However, relative
7102017c965SRod Evans  *	path names can be supplied as dependencies, e.g. dlopen("../libx.so.1").
7110aa3cd4dSrie  *
7122017c965SRod Evans  *  -	a PATHNAME() - this is the fully resolved path name of the object.  This
71367d74cc3SToomas Soome  *	name will differ from NAME() for all dynamic executables, and may differ
7142017c965SRod Evans  *	from the NAME() of dependencies, if the dependency is not a full path
71567d74cc3SToomas Soome  *	name, or the dependency resolves to a symbolic link.
7160aa3cd4dSrie  *
7172017c965SRod Evans  *  -	an ALIAS() name - these are alternative names by which the object has
71856deab07SRod Evans  *	been found, ie. when dependencies are loaded through a variety of
71956deab07SRod Evans  *	different symbolic links.
7200aa3cd4dSrie  *
7210aa3cd4dSrie  * The name pattern matching can differ depending on whether we are looking
7220aa3cd4dSrie  * for a full path name (path != 0), or a simple file name (path == 0).  Full
72356deab07SRod Evans  * path names typically match NAME() or PATHNAME() entries.
7240aa3cd4dSrie  *
7250aa3cd4dSrie  * For all full path name searches, the link-map names are taken as is.  For
7260aa3cd4dSrie  * simple file name searches, only the file name component of any link-map
7270aa3cd4dSrie  * names are used for comparison.
7280aa3cd4dSrie  */
72956deab07SRod Evans inline static Rt_map *
is_so_matched(Rt_map * lmp,const char * name,int path)7300aa3cd4dSrie is_so_matched(Rt_map *lmp, const char *name, int path)
7317c478bd9Sstevel@tonic-gate {
732cce0e03bSab 	Aliste		idx;
733cce0e03bSab 	const char	*cp;
7347c478bd9Sstevel@tonic-gate 
73556deab07SRod Evans 	if (_is_so_matched(name, NAME(lmp), path) == 0)
73656deab07SRod Evans 		return (lmp);
7370aa3cd4dSrie 
73856deab07SRod Evans 	if (PATHNAME(lmp) != NAME(lmp)) {
73956deab07SRod Evans 		if (_is_so_matched(name, PATHNAME(lmp), path) == 0)
74056deab07SRod Evans 			return (lmp);
7410aa3cd4dSrie 	}
7420aa3cd4dSrie 
743cce0e03bSab 	for (APLIST_TRAVERSE(ALIAS(lmp), idx, cp)) {
744cce0e03bSab 		if (_is_so_matched(name, cp, path) == 0)
7457c478bd9Sstevel@tonic-gate 			return (lmp);
7467c478bd9Sstevel@tonic-gate 	}
7477c478bd9Sstevel@tonic-gate 
74837ffaf83SRod Evans 	return (NULL);
7497c478bd9Sstevel@tonic-gate }
7507c478bd9Sstevel@tonic-gate 
7510aa3cd4dSrie /*
7520aa3cd4dSrie  * Files are opened by ld.so.1 to satisfy dependencies, filtees and dlopen()
7530aa3cd4dSrie  * requests.  Each request investigates the file based upon the callers
7549aa23310Srie  * environment.  Once a full path name has been established, the following
7559aa23310Srie  * checks are made:
7560aa3cd4dSrie  *
7572017c965SRod Evans  *  -	does the path exist in the link-map lists FullPathNode AVL tree?  if
7589aa23310Srie  *	so, the file is already loaded, and its associated link-map pointer
7599aa23310Srie  *	is returned.
7602017c965SRod Evans  *  -	does the path exist in the not-found AVL tree?  if so, this path has
7619aa23310Srie  *	already been determined to not exist, and a failure is returned.
7622017c965SRod Evans  *  -	a device/inode check, to ensure the same file isn't mapped multiple
7639aa23310Srie  *	times through different paths.  See file_open().
7649aa23310Srie  *
7659aa23310Srie  * However, there are cases where a test for an existing file name needs to be
7669aa23310Srie  * carried out, such as dlopen(NOLOAD) requests, dldump() requests, and as a
7679aa23310Srie  * final fallback to dependency loading.  These requests are handled by
7689aa23310Srie  * is_so_loaded().
7690aa3cd4dSrie  *
7700aa3cd4dSrie  * A traversal through the callers link-map list is carried out, and from each
7710aa3cd4dSrie  * link-map, a comparison is made against all of the various names by which the
77208278a5eSRod Evans  * object has been referenced.  is_so_matched() is used to compare the link-map
7739aa23310Srie  * names against the name being searched for.  Whether the search name is a full
7749aa23310Srie  * path name or a simple file name, governs what comparisons are made.
7750aa3cd4dSrie  *
7760aa3cd4dSrie  * A full path name, which is a fully resolved path name that starts with a "/"
7770aa3cd4dSrie  * character, or a relative path name that includes a "/" character, must match
77856deab07SRod Evans  * the link-map names exactly.  A simple file name, which is any name *not*
7790aa3cd4dSrie  * containing a "/" character, are matched against the file name component of
7800aa3cd4dSrie  * any link-map names.
7810aa3cd4dSrie  */
7827c478bd9Sstevel@tonic-gate Rt_map *
is_so_loaded(Lm_list * lml,const char * name,int * in_nfavl)7839aa23310Srie is_so_loaded(Lm_list *lml, const char *name, int *in_nfavl)
7847c478bd9Sstevel@tonic-gate {
7857c478bd9Sstevel@tonic-gate 	Rt_map		*lmp;
7867c478bd9Sstevel@tonic-gate 	avl_index_t	where;
7877c478bd9Sstevel@tonic-gate 	Lm_cntl		*lmc;
788cce0e03bSab 	Aliste		idx;
7890aa3cd4dSrie 	int		path = 0;
7907c478bd9Sstevel@tonic-gate 
7917c478bd9Sstevel@tonic-gate 	/*
7920aa3cd4dSrie 	 * If the name is a full path name, first determine if the path name is
7939aa23310Srie 	 * registered on the FullPathNode AVL, or not-found AVL trees.
7947c478bd9Sstevel@tonic-gate 	 */
7959aa23310Srie 	if (name[0] == '/') {
79656deab07SRod Evans 		uint_t	hash = sgs_str_hash(name);
79756deab07SRod Evans 
79856deab07SRod Evans 		if (((lmp = fpavl_recorded(lml, name, hash, &where)) != NULL) &&
7999aa23310Srie 		    ((FLAGS(lmp) & (FLG_RT_OBJECT | FLG_RT_DELETE)) == 0))
8009aa23310Srie 			return (lmp);
80156deab07SRod Evans 
80208278a5eSRod Evans 		if (pnavl_recorded(&nfavl, name, hash, NULL)) {
8039aa23310Srie 			/*
8049aa23310Srie 			 * For dlopen() and dlsym() fall backs, indicate that
8059aa23310Srie 			 * a registered not-found path has indicated that this
8069aa23310Srie 			 * object does not exist.
8079aa23310Srie 			 */
8089aa23310Srie 			if (in_nfavl)
8099aa23310Srie 				(*in_nfavl)++;
81037ffaf83SRod Evans 			return (NULL);
8119aa23310Srie 		}
8129aa23310Srie 	}
8137c478bd9Sstevel@tonic-gate 
8147c478bd9Sstevel@tonic-gate 	/*
8150aa3cd4dSrie 	 * Determine whether the name is a simple file name, or a path name.
8167c478bd9Sstevel@tonic-gate 	 */
8170aa3cd4dSrie 	if (strchr(name, '/'))
8180aa3cd4dSrie 		path++;
8197c478bd9Sstevel@tonic-gate 
8207c478bd9Sstevel@tonic-gate 	/*
8217c478bd9Sstevel@tonic-gate 	 * Loop through the callers link-map lists.
8227c478bd9Sstevel@tonic-gate 	 */
823cce0e03bSab 	for (ALIST_TRAVERSE(lml->lm_lists, idx, lmc)) {
824cb511613SAli Bahrami 		for (lmp = lmc->lc_head; lmp; lmp = NEXT_RT_MAP(lmp)) {
8257c478bd9Sstevel@tonic-gate 			if (FLAGS(lmp) & (FLG_RT_OBJECT | FLG_RT_DELETE))
8267c478bd9Sstevel@tonic-gate 				continue;
8277c478bd9Sstevel@tonic-gate 
8280aa3cd4dSrie 			if (is_so_matched(lmp, name, path))
8297c478bd9Sstevel@tonic-gate 				return (lmp);
8307c478bd9Sstevel@tonic-gate 		}
8317c478bd9Sstevel@tonic-gate 	}
83237ffaf83SRod Evans 	return (NULL);
8337c478bd9Sstevel@tonic-gate }
8347c478bd9Sstevel@tonic-gate 
8357c478bd9Sstevel@tonic-gate /*
8367c478bd9Sstevel@tonic-gate  * Tracing is enabled by the LD_TRACE_LOADED_OPTIONS environment variable which
8377c478bd9Sstevel@tonic-gate  * is normally set from ldd(1).  For each link map we load, print the load name
83808278a5eSRod Evans  * and the full pathname of the associated object.
8397c478bd9Sstevel@tonic-gate  */
8407c478bd9Sstevel@tonic-gate /* ARGSUSED4 */
8417c478bd9Sstevel@tonic-gate static void
trace_so(Rt_map * clmp,Rej_desc * rej,const char * name,const char * path,int alter,const char * nfound)8427c478bd9Sstevel@tonic-gate trace_so(Rt_map *clmp, Rej_desc *rej, const char *name, const char *path,
8437c478bd9Sstevel@tonic-gate     int alter, const char *nfound)
8447c478bd9Sstevel@tonic-gate {
8457c478bd9Sstevel@tonic-gate 	const char	*str = MSG_ORIG(MSG_STR_EMPTY);
8467c478bd9Sstevel@tonic-gate 	const char	*reject = MSG_ORIG(MSG_STR_EMPTY);
8477c478bd9Sstevel@tonic-gate 	char		_reject[PATH_MAX];
8487c478bd9Sstevel@tonic-gate 
8497c478bd9Sstevel@tonic-gate 	/*
8507c478bd9Sstevel@tonic-gate 	 * The first time through trace_so() will only have lddstub on the
8517c478bd9Sstevel@tonic-gate 	 * link-map list and the preloaded shared object is supplied as "path".
8527c478bd9Sstevel@tonic-gate 	 * As we don't want to print this shared object as a dependency, but
8537c478bd9Sstevel@tonic-gate 	 * instead inspect *its* dependencies, return.
8547c478bd9Sstevel@tonic-gate 	 */
8557c478bd9Sstevel@tonic-gate 	if (FLAGS1(clmp) & FL1_RT_LDDSTUB)
8567c478bd9Sstevel@tonic-gate 		return;
8577c478bd9Sstevel@tonic-gate 
8587c478bd9Sstevel@tonic-gate 	/*
8597c478bd9Sstevel@tonic-gate 	 * Without any rejection info, this is a supplied not-found condition.
8607c478bd9Sstevel@tonic-gate 	 */
8617c478bd9Sstevel@tonic-gate 	if (rej && (rej->rej_type == 0)) {
8627c478bd9Sstevel@tonic-gate 		(void) printf(nfound, name);
8637c478bd9Sstevel@tonic-gate 		return;
8647c478bd9Sstevel@tonic-gate 	}
8657c478bd9Sstevel@tonic-gate 
8667c478bd9Sstevel@tonic-gate 	/*
8677c478bd9Sstevel@tonic-gate 	 * If rejection information exists then establish what object was
8687c478bd9Sstevel@tonic-gate 	 * found and the reason for its rejection.
8697c478bd9Sstevel@tonic-gate 	 */
8707c478bd9Sstevel@tonic-gate 	if (rej) {
871de777a60Sab 		Conv_reject_desc_buf_t rej_buf;
872de777a60Sab 
8737c478bd9Sstevel@tonic-gate 		/* LINTED */
8747c478bd9Sstevel@tonic-gate 		(void) snprintf(_reject, PATH_MAX,
875de777a60Sab 		    MSG_INTL(ldd_reject[rej->rej_type]),
876ba2be530Sab 		    conv_reject_desc(rej, &rej_buf, M_MACH));
8777c478bd9Sstevel@tonic-gate 		if (rej->rej_name)
8787c478bd9Sstevel@tonic-gate 			path = rej->rej_name;
8797c478bd9Sstevel@tonic-gate 		reject = (char *)_reject;
8807c478bd9Sstevel@tonic-gate 
8817c478bd9Sstevel@tonic-gate 		/*
8827c478bd9Sstevel@tonic-gate 		 * Was an alternative pathname defined (from a configuration
8837c478bd9Sstevel@tonic-gate 		 * file).
8847c478bd9Sstevel@tonic-gate 		 */
88556deab07SRod Evans 		if (rej->rej_flags & FLG_REJ_ALTER)
8867c478bd9Sstevel@tonic-gate 			str = MSG_INTL(MSG_LDD_FIL_ALTER);
8877c478bd9Sstevel@tonic-gate 	} else {
8887c478bd9Sstevel@tonic-gate 		if (alter)
8897c478bd9Sstevel@tonic-gate 			str = MSG_INTL(MSG_LDD_FIL_ALTER);
8907c478bd9Sstevel@tonic-gate 	}
8917c478bd9Sstevel@tonic-gate 
8927c478bd9Sstevel@tonic-gate 	/*
8937c478bd9Sstevel@tonic-gate 	 * If the load name isn't a full pathname print its associated pathname
8947c478bd9Sstevel@tonic-gate 	 * together with all the other information we've gathered.
8957c478bd9Sstevel@tonic-gate 	 */
8967c478bd9Sstevel@tonic-gate 	if (*name == '/')
8977247f888Srie 		(void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), path, str, reject);
8987c478bd9Sstevel@tonic-gate 	else
8997247f888Srie 		(void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), name, path, str,
9007247f888Srie 		    reject);
9017c478bd9Sstevel@tonic-gate }
9027c478bd9Sstevel@tonic-gate 
9037c478bd9Sstevel@tonic-gate /*
9047c478bd9Sstevel@tonic-gate  * Establish a link-map mode, initializing it if it has just been loaded, or
9057c478bd9Sstevel@tonic-gate  * potentially updating it if it already exists.
9067c478bd9Sstevel@tonic-gate  */
9077c478bd9Sstevel@tonic-gate int
update_mode(Rt_map * lmp,int omode,int nmode)9087c478bd9Sstevel@tonic-gate update_mode(Rt_map *lmp, int omode, int nmode)
9097c478bd9Sstevel@tonic-gate {
910dffec89cSrie 	Lm_list	*lml = LIST(lmp);
9117c478bd9Sstevel@tonic-gate 	int	pmode = 0;
9127c478bd9Sstevel@tonic-gate 
9137c478bd9Sstevel@tonic-gate 	/*
9147c478bd9Sstevel@tonic-gate 	 * A newly loaded object hasn't had its mode set yet.  Modes are used to
9157c478bd9Sstevel@tonic-gate 	 * load dependencies, so don't propagate any parent or no-load flags, as
9167c478bd9Sstevel@tonic-gate 	 * these would adversely affect this objects ability to load any of its
9177c478bd9Sstevel@tonic-gate 	 * dependencies that aren't already loaded.  RTLD_FIRST is applicable to
9187c478bd9Sstevel@tonic-gate 	 * this objects handle creation only, and should not be propagated.
9197c478bd9Sstevel@tonic-gate 	 */
9207c478bd9Sstevel@tonic-gate 	if ((FLAGS(lmp) & FLG_RT_MODESET) == 0) {
9217c478bd9Sstevel@tonic-gate 		MODE(lmp) |= nmode & ~(RTLD_PARENT | RTLD_NOLOAD | RTLD_FIRST);
9227c478bd9Sstevel@tonic-gate 		FLAGS(lmp) |= FLG_RT_MODESET;
9237c478bd9Sstevel@tonic-gate 		return (1);
9247c478bd9Sstevel@tonic-gate 	}
9257c478bd9Sstevel@tonic-gate 
9267c478bd9Sstevel@tonic-gate 	/*
9277c478bd9Sstevel@tonic-gate 	 * Establish any new overriding modes.  RTLD_LAZY and RTLD_NOW should be
9287c478bd9Sstevel@tonic-gate 	 * represented individually (this is historic, as these two flags were
9297c478bd9Sstevel@tonic-gate 	 * the only flags originally available to dlopen()).  Other flags are
9307c478bd9Sstevel@tonic-gate 	 * accumulative, but have a hierarchy of preference.
9317c478bd9Sstevel@tonic-gate 	 */
9327c478bd9Sstevel@tonic-gate 	if ((omode & RTLD_LAZY) && (nmode & RTLD_NOW)) {
9337c478bd9Sstevel@tonic-gate 		MODE(lmp) &= ~RTLD_LAZY;
9347c478bd9Sstevel@tonic-gate 		pmode |= RTLD_NOW;
9357c478bd9Sstevel@tonic-gate 	}
9367c478bd9Sstevel@tonic-gate 
9377c478bd9Sstevel@tonic-gate 	pmode |= ((~omode & nmode) &
9387c478bd9Sstevel@tonic-gate 	    (RTLD_GLOBAL | RTLD_WORLD | RTLD_NODELETE));
9397c478bd9Sstevel@tonic-gate 	if (pmode) {
9405aefb655Srie 		DBG_CALL(Dbg_file_mode_promote(lmp, pmode));
9417c478bd9Sstevel@tonic-gate 		MODE(lmp) |= pmode;
9427c478bd9Sstevel@tonic-gate 	}
9437c478bd9Sstevel@tonic-gate 
9447c478bd9Sstevel@tonic-gate 	/*
9457c478bd9Sstevel@tonic-gate 	 * If this load is an RTLD_NOW request and the object has already been
9467c478bd9Sstevel@tonic-gate 	 * loaded non-RTLD_NOW, append this object to the relocation-now list
9477c478bd9Sstevel@tonic-gate 	 * of the objects associated control list.  Note, if the object hasn't
9487c478bd9Sstevel@tonic-gate 	 * yet been relocated, setting its MODE() to RTLD_NOW will establish
9497c478bd9Sstevel@tonic-gate 	 * full relocation processing when it eventually gets relocated.
9507c478bd9Sstevel@tonic-gate 	 */
9517c478bd9Sstevel@tonic-gate 	if ((pmode & RTLD_NOW) &&
9527c478bd9Sstevel@tonic-gate 	    (FLAGS(lmp) & (FLG_RT_RELOCED | FLG_RT_RELOCING))) {
9537c478bd9Sstevel@tonic-gate 		Lm_cntl	*lmc;
9547c478bd9Sstevel@tonic-gate 
9557c478bd9Sstevel@tonic-gate 		/* LINTED */
956cce0e03bSab 		lmc = (Lm_cntl *)alist_item_by_offset(LIST(lmp)->lm_lists,
957cce0e03bSab 		    CNTL(lmp));
958cce0e03bSab 		(void) aplist_append(&lmc->lc_now, lmp, AL_CNT_LMNOW);
9597c478bd9Sstevel@tonic-gate 	}
9607c478bd9Sstevel@tonic-gate 
9617c478bd9Sstevel@tonic-gate 	/*
962dffec89cSrie 	 * If this objects .init has been collected but has not yet been called,
963dffec89cSrie 	 * it may be necessary to reevaluate the object using tsort().  For
9647c478bd9Sstevel@tonic-gate 	 * example, a new dlopen() hierarchy may bind to uninitialized objects
9657c478bd9Sstevel@tonic-gate 	 * that are already loaded, or a dlopen(RTLD_NOW) can establish new
9667c478bd9Sstevel@tonic-gate 	 * bindings between already loaded objects that require the tsort()
967dffec89cSrie 	 * information be recomputed.  If however, no new objects have been
968dffec89cSrie 	 * added to the process, and this object hasn't been promoted, don't
969dffec89cSrie 	 * bother reevaluating the .init.  The present tsort() information is
970dffec89cSrie 	 * probably as accurate as necessary, and by not establishing a parallel
971dffec89cSrie 	 * tsort() we can help reduce the amount of recursion possible between
972dffec89cSrie 	 * .inits.
9737c478bd9Sstevel@tonic-gate 	 */
974dffec89cSrie 	if (((FLAGS(lmp) &
975dffec89cSrie 	    (FLG_RT_INITCLCT | FLG_RT_INITCALL)) == FLG_RT_INITCLCT) &&
976dffec89cSrie 	    ((lml->lm_flags & LML_FLG_OBJADDED) || ((pmode & RTLD_NOW) &&
977dffec89cSrie 	    (FLAGS(lmp) & (FLG_RT_RELOCED | FLG_RT_RELOCING))))) {
9787c478bd9Sstevel@tonic-gate 		FLAGS(lmp) &= ~FLG_RT_INITCLCT;
9797c478bd9Sstevel@tonic-gate 		LIST(lmp)->lm_init++;
980dffec89cSrie 		LIST(lmp)->lm_flags |= LML_FLG_OBJREEVAL;
9817c478bd9Sstevel@tonic-gate 	}
9827c478bd9Sstevel@tonic-gate 
9837c478bd9Sstevel@tonic-gate 	return (pmode);
9847c478bd9Sstevel@tonic-gate }
9857c478bd9Sstevel@tonic-gate 
9867c478bd9Sstevel@tonic-gate /*
9877c478bd9Sstevel@tonic-gate  * Determine whether an alias name already exists, and if not create one.  This
9887c478bd9Sstevel@tonic-gate  * is typically used to retain dependency names, such as "libc.so.1", which
9897c478bd9Sstevel@tonic-gate  * would have been expanded to full path names when they were loaded.  The
99056deab07SRod Evans  * full path names (NAME() and possibly PATHNAME()) are maintained on the
99156deab07SRod Evans  * FullPathNode AVL tree, and thus would have been matched by fpavl_loaded()
99256deab07SRod Evans  * during file_open().
9937c478bd9Sstevel@tonic-gate  */
9947c478bd9Sstevel@tonic-gate int
append_alias(Rt_map * lmp,const char * str,int * added)9957c478bd9Sstevel@tonic-gate append_alias(Rt_map *lmp, const char *str, int *added)
9967c478bd9Sstevel@tonic-gate {
99756deab07SRod Evans 	const char	*cp;
99856deab07SRod Evans 	Aliste		idx;
9997c478bd9Sstevel@tonic-gate 
10007c478bd9Sstevel@tonic-gate 	/*
10017c478bd9Sstevel@tonic-gate 	 * Determine if this filename is already on the alias list.
10027c478bd9Sstevel@tonic-gate 	 */
1003cce0e03bSab 	for (APLIST_TRAVERSE(ALIAS(lmp), idx, cp)) {
1004cce0e03bSab 		if (strcmp(cp, str) == 0)
10057c478bd9Sstevel@tonic-gate 			return (1);
10067c478bd9Sstevel@tonic-gate 	}
10077c478bd9Sstevel@tonic-gate 
10087c478bd9Sstevel@tonic-gate 	/*
10097c478bd9Sstevel@tonic-gate 	 * This is a new alias, append it to the alias list.
10107c478bd9Sstevel@tonic-gate 	 */
101156deab07SRod Evans 	if (((cp = stravl_insert(str, 0, 0, 0)) == NULL) ||
101256deab07SRod Evans 	    (aplist_append(&ALIAS(lmp), cp, AL_CNT_ALIAS) == NULL))
10137c478bd9Sstevel@tonic-gate 		return (0);
10147c478bd9Sstevel@tonic-gate 
10157c478bd9Sstevel@tonic-gate 	if (added)
10167c478bd9Sstevel@tonic-gate 		*added = 1;
10177c478bd9Sstevel@tonic-gate 	return (1);
10187c478bd9Sstevel@tonic-gate }
10197c478bd9Sstevel@tonic-gate 
10207c478bd9Sstevel@tonic-gate /*
10217c478bd9Sstevel@tonic-gate  * Determine whether a file is already loaded by comparing device and inode
10227c478bd9Sstevel@tonic-gate  * values.
10237c478bd9Sstevel@tonic-gate  */
10247c478bd9Sstevel@tonic-gate static Rt_map *
is_devinode_loaded(rtld_stat_t * status,Lm_list * lml,const char * name,uint_t flags)1025cb511613SAli Bahrami is_devinode_loaded(rtld_stat_t *status, Lm_list *lml, const char *name,
10267c478bd9Sstevel@tonic-gate     uint_t flags)
10277c478bd9Sstevel@tonic-gate {
10287c478bd9Sstevel@tonic-gate 	Lm_cntl	*lmc;
1029cce0e03bSab 	Aliste	idx;
10307c478bd9Sstevel@tonic-gate 
10317c478bd9Sstevel@tonic-gate 	/*
10327c478bd9Sstevel@tonic-gate 	 * If this is an auditor, it will have been opened on a new link-map.
10338af2c5b9Srie 	 * To prevent multiple occurrences of the same auditor on multiple
10347c478bd9Sstevel@tonic-gate 	 * link-maps, search the head of each link-map list and see if this
10357c478bd9Sstevel@tonic-gate 	 * object is already loaded as an auditor.
10367c478bd9Sstevel@tonic-gate 	 */
10377c478bd9Sstevel@tonic-gate 	if (flags & FLG_RT_AUDIT) {
103857ef7aa9SRod Evans 		Lm_list	*lml;
10397c478bd9Sstevel@tonic-gate 
104057ef7aa9SRod Evans 		for (APLIST_TRAVERSE(dynlm_list, idx, lml)) {
10417c478bd9Sstevel@tonic-gate 			Rt_map	*nlmp = lml->lm_head;
10427c478bd9Sstevel@tonic-gate 
10437c478bd9Sstevel@tonic-gate 			if (nlmp && ((FLAGS(nlmp) &
10447c478bd9Sstevel@tonic-gate 			    (FLG_RT_AUDIT | FLG_RT_DELETE)) == FLG_RT_AUDIT) &&
10457c478bd9Sstevel@tonic-gate 			    (STDEV(nlmp) == status->st_dev) &&
10467c478bd9Sstevel@tonic-gate 			    (STINO(nlmp) == status->st_ino))
10477c478bd9Sstevel@tonic-gate 				return (nlmp);
10487c478bd9Sstevel@tonic-gate 		}
104937ffaf83SRod Evans 		return (NULL);
10507c478bd9Sstevel@tonic-gate 	}
10517c478bd9Sstevel@tonic-gate 
10527c478bd9Sstevel@tonic-gate 	/*
10537c478bd9Sstevel@tonic-gate 	 * If the file has been found determine from the new files status
10547c478bd9Sstevel@tonic-gate 	 * information if this file is actually linked to one we already have
10557c478bd9Sstevel@tonic-gate 	 * mapped.  This catches symlink names not caught by is_so_loaded().
10567c478bd9Sstevel@tonic-gate 	 */
1057cce0e03bSab 	for (ALIST_TRAVERSE(lml->lm_lists, idx, lmc)) {
10587c478bd9Sstevel@tonic-gate 		Rt_map	*nlmp;
10597c478bd9Sstevel@tonic-gate 
1060cb511613SAli Bahrami 		for (nlmp = lmc->lc_head; nlmp; nlmp = NEXT_RT_MAP(nlmp)) {
10617c478bd9Sstevel@tonic-gate 			if ((FLAGS(nlmp) & FLG_RT_DELETE) ||
10627c478bd9Sstevel@tonic-gate 			    (FLAGS1(nlmp) & FL1_RT_LDDSTUB))
10637c478bd9Sstevel@tonic-gate 				continue;
10647c478bd9Sstevel@tonic-gate 
10657c478bd9Sstevel@tonic-gate 			if ((STDEV(nlmp) != status->st_dev) ||
10667c478bd9Sstevel@tonic-gate 			    (STINO(nlmp) != status->st_ino))
10677c478bd9Sstevel@tonic-gate 				continue;
10687c478bd9Sstevel@tonic-gate 
10697c478bd9Sstevel@tonic-gate 			if (lml->lm_flags & LML_FLG_TRC_VERBOSE) {
10707247f888Srie 				/* BEGIN CSTYLED */
10717c478bd9Sstevel@tonic-gate 				if (*name == '/')
10727c478bd9Sstevel@tonic-gate 				    (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH),
10737c478bd9Sstevel@tonic-gate 					name, MSG_ORIG(MSG_STR_EMPTY),
10747c478bd9Sstevel@tonic-gate 					MSG_ORIG(MSG_STR_EMPTY));
10757c478bd9Sstevel@tonic-gate 				else
10767c478bd9Sstevel@tonic-gate 				    (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV),
10777c478bd9Sstevel@tonic-gate 					name, NAME(nlmp),
10787c478bd9Sstevel@tonic-gate 					MSG_ORIG(MSG_STR_EMPTY),
10797c478bd9Sstevel@tonic-gate 					MSG_ORIG(MSG_STR_EMPTY));
10807247f888Srie 				/* END CSTYLED */
10817c478bd9Sstevel@tonic-gate 			}
10827c478bd9Sstevel@tonic-gate 			return (nlmp);
10837c478bd9Sstevel@tonic-gate 		}
10847c478bd9Sstevel@tonic-gate 	}
108537ffaf83SRod Evans 	return (NULL);
10867c478bd9Sstevel@tonic-gate }
10877c478bd9Sstevel@tonic-gate 
10887c478bd9Sstevel@tonic-gate /*
10897c478bd9Sstevel@tonic-gate  * Generate any error messages indicating a file could not be found.  When
10907c478bd9Sstevel@tonic-gate  * preloading or auditing a secure application, it can be a little more helpful
10917c478bd9Sstevel@tonic-gate  * to indicate that a search of secure directories has failed, so adjust the
10927c478bd9Sstevel@tonic-gate  * messages accordingly.
10937c478bd9Sstevel@tonic-gate  */
10947c478bd9Sstevel@tonic-gate void
file_notfound(Lm_list * lml,const char * name,Rt_map * clmp,uint_t flags,Rej_desc * rej)10957c478bd9Sstevel@tonic-gate file_notfound(Lm_list *lml, const char *name, Rt_map *clmp, uint_t flags,
109656deab07SRod Evans     Rej_desc *rej)
10977c478bd9Sstevel@tonic-gate {
10987c478bd9Sstevel@tonic-gate 	int	secure = 0;
10997c478bd9Sstevel@tonic-gate 
11007c478bd9Sstevel@tonic-gate 	if ((rtld_flags & RT_FL_SECURE) &&
11017c478bd9Sstevel@tonic-gate 	    (flags & (FLG_RT_PRELOAD | FLG_RT_AUDIT)))
11027c478bd9Sstevel@tonic-gate 		secure++;
11037c478bd9Sstevel@tonic-gate 
11047c478bd9Sstevel@tonic-gate 	if (lml->lm_flags & LML_FLG_TRC_ENABLE) {
11057c478bd9Sstevel@tonic-gate 		/*
11067c478bd9Sstevel@tonic-gate 		 * Under ldd(1), auxiliary filtees that can't be loaded are
11077c478bd9Sstevel@tonic-gate 		 * ignored, unless verbose errors are requested.
11087c478bd9Sstevel@tonic-gate 		 */
11097c478bd9Sstevel@tonic-gate 		if ((rtld_flags & RT_FL_SILENCERR) &&
11107c478bd9Sstevel@tonic-gate 		    ((lml->lm_flags & LML_FLG_TRC_VERBOSE) == 0))
11117c478bd9Sstevel@tonic-gate 			return;
11127c478bd9Sstevel@tonic-gate 
11137c478bd9Sstevel@tonic-gate 		if (secure)
11147c478bd9Sstevel@tonic-gate 			trace_so(clmp, rej, name, 0, 0,
11157c478bd9Sstevel@tonic-gate 			    MSG_INTL(MSG_LDD_SEC_NFOUND));
11167c478bd9Sstevel@tonic-gate 		else
11177c478bd9Sstevel@tonic-gate 			trace_so(clmp, rej, name, 0, 0,
11187c478bd9Sstevel@tonic-gate 			    MSG_INTL(MSG_LDD_FIL_NFOUND));
11197c478bd9Sstevel@tonic-gate 		return;
11207c478bd9Sstevel@tonic-gate 	}
11217c478bd9Sstevel@tonic-gate 
11227c478bd9Sstevel@tonic-gate 	if (rej->rej_type) {
1123de777a60Sab 		Conv_reject_desc_buf_t rej_buf;
1124de777a60Sab 
11255aefb655Srie 		eprintf(lml, ERR_FATAL, MSG_INTL(err_reject[rej->rej_type]),
11267c478bd9Sstevel@tonic-gate 		    rej->rej_name ? rej->rej_name : MSG_INTL(MSG_STR_UNKNOWN),
1127ba2be530Sab 		    conv_reject_desc(rej, &rej_buf, M_MACH));
11287c478bd9Sstevel@tonic-gate 		return;
11297c478bd9Sstevel@tonic-gate 	}
11307c478bd9Sstevel@tonic-gate 
11317c478bd9Sstevel@tonic-gate 	if (secure)
11325aefb655Srie 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SEC_OPEN), name);
11337c478bd9Sstevel@tonic-gate 	else
11345aefb655Srie 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), name,
11357c478bd9Sstevel@tonic-gate 		    strerror(ENOENT));
11367c478bd9Sstevel@tonic-gate }
11377c478bd9Sstevel@tonic-gate 
11387c478bd9Sstevel@tonic-gate static int
file_open(int err,Lm_list * lml,Rt_map * clmp,uint_t flags,Fdesc * fdp,Rej_desc * rej,int * in_nfavl)113956deab07SRod Evans file_open(int err, Lm_list *lml, Rt_map *clmp, uint_t flags, Fdesc *fdp,
114056deab07SRod Evans     Rej_desc *rej, int *in_nfavl)
11417c478bd9Sstevel@tonic-gate {
1142cb511613SAli Bahrami 	rtld_stat_t	status;
11437c478bd9Sstevel@tonic-gate 	Rt_map		*nlmp;
11449aa23310Srie 	avl_index_t	nfavlwhere = 0;
114556deab07SRod Evans 	const char	*oname = fdp->fd_oname, *nname = fdp->fd_nname;
114656deab07SRod Evans 	uint_t		hash = sgs_str_hash(nname);
11477c478bd9Sstevel@tonic-gate 
11487c478bd9Sstevel@tonic-gate 
114956deab07SRod Evans 	if ((nname = stravl_insert(fdp->fd_nname, hash, 0, 0)) == NULL)
115056deab07SRod Evans 		return (0);
115156deab07SRod Evans 	fdp->fd_nname = nname;
115256deab07SRod Evans 
115356deab07SRod Evans 	if ((err == 0) && (fdp->fd_flags & FLG_FD_ALTER))
11545aefb655Srie 		DBG_CALL(Dbg_file_config_obj(lml, oname, 0, nname));
11557c478bd9Sstevel@tonic-gate 
11567c478bd9Sstevel@tonic-gate 	/*
11577c478bd9Sstevel@tonic-gate 	 * If we're dealing with a full pathname, determine whether this
11587c478bd9Sstevel@tonic-gate 	 * pathname is already known.  Other pathnames fall through to the
11597c478bd9Sstevel@tonic-gate 	 * dev/inode check, as even though the pathname may look the same as
11607c478bd9Sstevel@tonic-gate 	 * one previously used, the process may have changed directory.
11617c478bd9Sstevel@tonic-gate 	 */
11627c478bd9Sstevel@tonic-gate 	if ((err == 0) && (nname[0] == '/')) {
116356deab07SRod Evans 		if ((nlmp = fpavl_recorded(lml, nname, hash,
116456deab07SRod Evans 		    &(fdp->fd_avlwhere))) != NULL) {
116556deab07SRod Evans 			fdp->fd_lmp = nlmp;
11667c478bd9Sstevel@tonic-gate 			return (1);
11677c478bd9Sstevel@tonic-gate 		}
116808278a5eSRod Evans 		if (pnavl_recorded(&nfavl, nname, hash, &nfavlwhere)) {
11699aa23310Srie 			/*
11709aa23310Srie 			 * For dlopen() and dlsym() fall backs, indicate that
11719aa23310Srie 			 * a registered not-found path has indicated that this
11729aa23310Srie 			 * object does not exist.  If this path has been
117308278a5eSRod Evans 			 * constructed as part of expanding a CAPABILITY
117408278a5eSRod Evans 			 * directory, this is a silent failure, where no
117508278a5eSRod Evans 			 * rejection message is created.
11769aa23310Srie 			 */
11779aa23310Srie 			if (in_nfavl)
11789aa23310Srie 				(*in_nfavl)++;
11799aa23310Srie 			return (0);
11809aa23310Srie 		}
11817c478bd9Sstevel@tonic-gate 	}
11827c478bd9Sstevel@tonic-gate 
1183cb511613SAli Bahrami 	if ((err == 0) && ((rtld_stat(nname, &status)) != -1)) {
11847c478bd9Sstevel@tonic-gate 		char	path[PATH_MAX];
11857c478bd9Sstevel@tonic-gate 		int	fd, size, added;
11867c478bd9Sstevel@tonic-gate 
11877c478bd9Sstevel@tonic-gate 		/*
11887c478bd9Sstevel@tonic-gate 		 * If this path has been constructed as part of expanding a
118908278a5eSRod Evans 		 * CAPABILITY directory, ignore any subdirectories.  As this
119008278a5eSRod Evans 		 * is a silent failure, no rejection message is created.  For
119108278a5eSRod Evans 		 * any other reference that expands to a directory, fall
119208278a5eSRod Evans 		 * through to construct a meaningful rejection message.
11937c478bd9Sstevel@tonic-gate 		 */
119408278a5eSRod Evans 		if ((flags & FLG_RT_CAP) &&
119556deab07SRod Evans 		    ((status.st_mode & S_IFMT) == S_IFDIR))
119656deab07SRod Evans 			return (0);
119756deab07SRod Evans 
119856deab07SRod Evans 		/*
119956deab07SRod Evans 		 * If this is a directory (which can't be mmap()'ed) generate a
120056deab07SRod Evans 		 * precise error message.
120156deab07SRod Evans 		 */
120256deab07SRod Evans 		if ((status.st_mode & S_IFMT) == S_IFDIR) {
120356deab07SRod Evans 			rej->rej_name = nname;
120456deab07SRod Evans 			if (fdp->fd_flags & FLG_FD_ALTER)
120556deab07SRod Evans 				rej->rej_flags = FLG_REJ_ALTER;
120656deab07SRod Evans 			rej->rej_type = SGS_REJ_STR;
120756deab07SRod Evans 			rej->rej_str = strerror(EISDIR);
120856deab07SRod Evans 			DBG_CALL(Dbg_file_rejected(lml, rej, M_MACH));
12097c478bd9Sstevel@tonic-gate 			return (0);
12108521e5e6Srie 		}
12117c478bd9Sstevel@tonic-gate 
12127c478bd9Sstevel@tonic-gate 		/*
12137c478bd9Sstevel@tonic-gate 		 * Resolve the filename and determine whether the resolved name
12147c478bd9Sstevel@tonic-gate 		 * is already known.  Typically, the previous fpavl_loaded()
12157c478bd9Sstevel@tonic-gate 		 * will have caught this, as both NAME() and PATHNAME() for a
121656deab07SRod Evans 		 * link-map are recorded in the FullPathNode AVL tree.  However,
12177c478bd9Sstevel@tonic-gate 		 * instances exist where a file can be replaced (loop-back
12187c478bd9Sstevel@tonic-gate 		 * mounts, bfu, etc.), and reference is made to the original
12197c478bd9Sstevel@tonic-gate 		 * file through a symbolic link.  By checking the pathname here,
12207c478bd9Sstevel@tonic-gate 		 * we don't fall through to the dev/inode check and conclude
12217c478bd9Sstevel@tonic-gate 		 * that a new file should be loaded.
12227c478bd9Sstevel@tonic-gate 		 */
122356deab07SRod Evans 		if ((nname[0] == '/') &&
12247c478bd9Sstevel@tonic-gate 		    ((size = resolvepath(nname, path, (PATH_MAX - 1))) > 0)) {
12257c478bd9Sstevel@tonic-gate 			path[size] = '\0';
12267c478bd9Sstevel@tonic-gate 
122756deab07SRod Evans 			fdp->fd_flags |= FLG_FD_RESOLVED;
122856deab07SRod Evans 
12297c478bd9Sstevel@tonic-gate 			if (strcmp(nname, path)) {
123024a6229eSrie 				if ((nlmp =
123156deab07SRod Evans 				    fpavl_recorded(lml, path, 0, 0)) != NULL) {
12327c478bd9Sstevel@tonic-gate 					added = 0;
12337c478bd9Sstevel@tonic-gate 
12347c478bd9Sstevel@tonic-gate 					if (append_alias(nlmp, nname,
12357c478bd9Sstevel@tonic-gate 					    &added) == 0)
12367c478bd9Sstevel@tonic-gate 						return (0);
12377247f888Srie 					/* BEGIN CSTYLED */
12387c478bd9Sstevel@tonic-gate 					if (added)
123910a4fa49Srie 					    DBG_CALL(Dbg_file_skip(LIST(clmp),
12405aefb655Srie 						NAME(nlmp), nname));
12417247f888Srie 					/* END CSTYLED */
124256deab07SRod Evans 					fdp->fd_lmp = nlmp;
12437c478bd9Sstevel@tonic-gate 					return (1);
12447c478bd9Sstevel@tonic-gate 				}
12457c478bd9Sstevel@tonic-gate 
12467c478bd9Sstevel@tonic-gate 				/*
12477c478bd9Sstevel@tonic-gate 				 * If this pathname hasn't been loaded, save
12487c478bd9Sstevel@tonic-gate 				 * the resolved pathname so that it doesn't
12497c478bd9Sstevel@tonic-gate 				 * have to be recomputed as part of fullpath()
12507c478bd9Sstevel@tonic-gate 				 * processing.
12517c478bd9Sstevel@tonic-gate 				 */
125256deab07SRod Evans 				if ((fdp->fd_pname = stravl_insert(path, 0,
125356deab07SRod Evans 				    (size + 1), 0)) == NULL)
12547c478bd9Sstevel@tonic-gate 					return (0);
12557c478bd9Sstevel@tonic-gate 			}
12567c478bd9Sstevel@tonic-gate 		}
12577c478bd9Sstevel@tonic-gate 
1258*80422cafSToomas Soome 		nlmp = is_devinode_loaded(&status, lml, nname, flags);
1259*80422cafSToomas Soome 		if (nlmp != NULL) {
1260c75e1b9dSrie 			if (flags & FLG_RT_AUDIT) {
1261c75e1b9dSrie 				/*
1262c75e1b9dSrie 				 * If we've been requested to load an auditor,
1263c75e1b9dSrie 				 * and an auditor of the same name already
1264c75e1b9dSrie 				 * exists, then the original auditor is used.
1265c75e1b9dSrie 				 */
1266c75e1b9dSrie 				DBG_CALL(Dbg_audit_skip(LIST(clmp),
1267c75e1b9dSrie 				    NAME(nlmp), LIST(nlmp)->lm_lmidstr));
1268c75e1b9dSrie 			} else {
1269c75e1b9dSrie 				/*
1270c75e1b9dSrie 				 * Otherwise, if an alternatively named file
1271c75e1b9dSrie 				 * has been found for the same dev/inode, add
127256deab07SRod Evans 				 * a new name alias.  Insert any alias full path
127356deab07SRod Evans 				 * name in the FullPathNode AVL tree.
1274c75e1b9dSrie 				 */
1275c75e1b9dSrie 				added = 0;
12767c478bd9Sstevel@tonic-gate 
1277c75e1b9dSrie 				if (append_alias(nlmp, nname, &added) == 0)
12787c478bd9Sstevel@tonic-gate 					return (0);
1279c75e1b9dSrie 				if (added) {
1280c75e1b9dSrie 					if ((nname[0] == '/') &&
1281c75e1b9dSrie 					    (fpavl_insert(lml, nlmp,
1282c75e1b9dSrie 					    nname, 0) == 0))
1283c75e1b9dSrie 						return (0);
1284c75e1b9dSrie 					DBG_CALL(Dbg_file_skip(LIST(clmp),
1285c75e1b9dSrie 					    NAME(nlmp), nname));
1286c75e1b9dSrie 				}
12877c478bd9Sstevel@tonic-gate 			}
1288c75e1b9dSrie 
1289c75e1b9dSrie 			/*
1290c75e1b9dSrie 			 * Record in the file descriptor the existing object
1291c75e1b9dSrie 			 * that satisfies this open request.
1292c75e1b9dSrie 			 */
129356deab07SRod Evans 			fdp->fd_lmp = nlmp;
12947c478bd9Sstevel@tonic-gate 			return (1);
12957c478bd9Sstevel@tonic-gate 		}
12967c478bd9Sstevel@tonic-gate 
12977c478bd9Sstevel@tonic-gate 		if ((fd = open(nname, O_RDONLY, 0)) == -1) {
12987c478bd9Sstevel@tonic-gate 			/*
12997c478bd9Sstevel@tonic-gate 			 * As the file must exist for the previous stat() to
13007c478bd9Sstevel@tonic-gate 			 * have succeeded, record the error condition.
13017c478bd9Sstevel@tonic-gate 			 */
13027c478bd9Sstevel@tonic-gate 			rej->rej_type = SGS_REJ_STR;
13037c478bd9Sstevel@tonic-gate 			rej->rej_str = strerror(errno);
13047c478bd9Sstevel@tonic-gate 		} else {
130556deab07SRod Evans 			/*
130656deab07SRod Evans 			 * Map the object.  A successful return indicates that
130756deab07SRod Evans 			 * the object is appropriate for ld.so.1 processing.
130856deab07SRod Evans 			 */
130956deab07SRod Evans 			fdp->fd_ftp = map_obj(lml, fdp, status.st_size, nname,
131056deab07SRod Evans 			    fd, rej);
131156deab07SRod Evans 			(void) close(fd);
13127c478bd9Sstevel@tonic-gate 
131356deab07SRod Evans 			if (fdp->fd_ftp != NULL) {
131456deab07SRod Evans 				fdp->fd_dev = status.st_dev;
131556deab07SRod Evans 				fdp->fd_ino = status.st_ino;
13167c478bd9Sstevel@tonic-gate 				return (1);
13177c478bd9Sstevel@tonic-gate 			}
13187c478bd9Sstevel@tonic-gate 		}
13197c478bd9Sstevel@tonic-gate 
13207c478bd9Sstevel@tonic-gate 	} else if (errno != ENOENT) {
13217c478bd9Sstevel@tonic-gate 		/*
13227c478bd9Sstevel@tonic-gate 		 * If the open() failed for anything other than the file not
13237c478bd9Sstevel@tonic-gate 		 * existing, record the error condition.
13247c478bd9Sstevel@tonic-gate 		 */
13257c478bd9Sstevel@tonic-gate 		rej->rej_type = SGS_REJ_STR;
13267c478bd9Sstevel@tonic-gate 		rej->rej_str = strerror(errno);
13277c478bd9Sstevel@tonic-gate 	}
13287c478bd9Sstevel@tonic-gate 
13299aa23310Srie 	/*
13309aa23310Srie 	 * Regardless of error, duplicate and record any full path names that
13319aa23310Srie 	 * can't be used on the "not-found" AVL tree.
13329aa23310Srie 	 */
133356deab07SRod Evans 	if (nname[0] == '/')
133456deab07SRod Evans 		nfavl_insert(nname, nfavlwhere);
13359aa23310Srie 
13367c478bd9Sstevel@tonic-gate 	/*
13377c478bd9Sstevel@tonic-gate 	 * Indicate any rejection.
13387c478bd9Sstevel@tonic-gate 	 */
13397c478bd9Sstevel@tonic-gate 	if (rej->rej_type) {
13407c478bd9Sstevel@tonic-gate 		rej->rej_name = nname;
134156deab07SRod Evans 		if (fdp->fd_flags & FLG_FD_ALTER)
134256deab07SRod Evans 			rej->rej_flags = FLG_REJ_ALTER;
1343ba2be530Sab 		DBG_CALL(Dbg_file_rejected(lml, rej, M_MACH));
13447c478bd9Sstevel@tonic-gate 	}
13457c478bd9Sstevel@tonic-gate 	return (0);
13467c478bd9Sstevel@tonic-gate }
13477c478bd9Sstevel@tonic-gate 
13487c478bd9Sstevel@tonic-gate /*
13497c478bd9Sstevel@tonic-gate  * Find a full pathname (it contains a "/").
13507c478bd9Sstevel@tonic-gate  */
13517c478bd9Sstevel@tonic-gate int
find_path(Lm_list * lml,Rt_map * clmp,uint_t flags,Fdesc * fdp,Rej_desc * rej,int * in_nfavl)135256deab07SRod Evans find_path(Lm_list *lml, Rt_map *clmp, uint_t flags, Fdesc *fdp, Rej_desc *rej,
135356deab07SRod Evans     int *in_nfavl)
13547c478bd9Sstevel@tonic-gate {
135556deab07SRod Evans 	const char	*oname = fdp->fd_oname;
135656deab07SRod Evans 	int		err = 0;
13577c478bd9Sstevel@tonic-gate 
13587c478bd9Sstevel@tonic-gate 	/*
13597c478bd9Sstevel@tonic-gate 	 * If directory configuration exists determine if this path is known.
13607c478bd9Sstevel@tonic-gate 	 */
13617c478bd9Sstevel@tonic-gate 	if (rtld_flags & RT_FL_DIRCFG) {
13627c478bd9Sstevel@tonic-gate 		Rtc_obj		*obj;
13637c478bd9Sstevel@tonic-gate 		const char	*aname;
13647c478bd9Sstevel@tonic-gate 
13657c478bd9Sstevel@tonic-gate 		if ((obj = elf_config_ent(oname, (Word)elf_hash(oname),
13667c478bd9Sstevel@tonic-gate 		    0, &aname)) != 0) {
13677c478bd9Sstevel@tonic-gate 			/*
13687c478bd9Sstevel@tonic-gate 			 * If the configuration file states that this path is a
13697c478bd9Sstevel@tonic-gate 			 * directory, or the path is explicitly defined as
13707c478bd9Sstevel@tonic-gate 			 * non-existent (ie. a unused platform specific
13717c478bd9Sstevel@tonic-gate 			 * library), then go no further.
13727c478bd9Sstevel@tonic-gate 			 */
13737c478bd9Sstevel@tonic-gate 			if (obj->co_flags & RTC_OBJ_DIRENT) {
13747c478bd9Sstevel@tonic-gate 				err = EISDIR;
13757c478bd9Sstevel@tonic-gate 			} else if ((obj->co_flags &
13767c478bd9Sstevel@tonic-gate 			    (RTC_OBJ_NOEXIST | RTC_OBJ_ALTER)) ==
13777c478bd9Sstevel@tonic-gate 			    RTC_OBJ_NOEXIST) {
13787c478bd9Sstevel@tonic-gate 				err = ENOENT;
13797c478bd9Sstevel@tonic-gate 			} else if ((obj->co_flags & RTC_OBJ_ALTER) &&
13807c478bd9Sstevel@tonic-gate 			    (rtld_flags & RT_FL_OBJALT) && (lml == &lml_main)) {
13817c478bd9Sstevel@tonic-gate 				int	ret;
13827c478bd9Sstevel@tonic-gate 
138356deab07SRod Evans 				fdp->fd_flags |= FLG_FD_ALTER;
138456deab07SRod Evans 				fdp->fd_nname = aname;
138556deab07SRod Evans 
13867c478bd9Sstevel@tonic-gate 				/*
13877c478bd9Sstevel@tonic-gate 				 * Attempt to open the alternative path.  If
13887c478bd9Sstevel@tonic-gate 				 * this fails, and the alternative is flagged
13897c478bd9Sstevel@tonic-gate 				 * as optional, fall through to open the
13907c478bd9Sstevel@tonic-gate 				 * original path.
13917c478bd9Sstevel@tonic-gate 				 */
13925aefb655Srie 				DBG_CALL(Dbg_libs_found(lml, aname,
13935aefb655Srie 				    FLG_FD_ALTER));
139456deab07SRod Evans 				ret = file_open(0, lml, clmp, flags, fdp,
139556deab07SRod Evans 				    rej, in_nfavl);
139656deab07SRod Evans 				if (ret || ((obj->co_flags &
139756deab07SRod Evans 				    RTC_OBJ_OPTINAL) == 0))
13987c478bd9Sstevel@tonic-gate 					return (ret);
13997c478bd9Sstevel@tonic-gate 
140056deab07SRod Evans 				fdp->fd_flags &= ~FLG_FD_ALTER;
14017c478bd9Sstevel@tonic-gate 			}
14027c478bd9Sstevel@tonic-gate 		}
14037c478bd9Sstevel@tonic-gate 	}
14045aefb655Srie 	DBG_CALL(Dbg_libs_found(lml, oname, 0));
140556deab07SRod Evans 	fdp->fd_nname = oname;
140656deab07SRod Evans 	return (file_open(err, lml, clmp, flags, fdp, rej, in_nfavl));
14077c478bd9Sstevel@tonic-gate }
14087c478bd9Sstevel@tonic-gate 
14097c478bd9Sstevel@tonic-gate /*
14107c478bd9Sstevel@tonic-gate  * Find a simple filename (it doesn't contain a "/").
14117c478bd9Sstevel@tonic-gate  */
14127c478bd9Sstevel@tonic-gate static int
_find_file(Lm_list * lml,Rt_map * clmp,uint_t flags,Fdesc * fdp,Rej_desc * rej,Pdesc * pdp,int aflag,int * in_nfavl)141356deab07SRod Evans _find_file(Lm_list *lml, Rt_map *clmp, uint_t flags, Fdesc *fdp, Rej_desc *rej,
141456deab07SRod Evans     Pdesc *pdp, int aflag, int *in_nfavl)
14157c478bd9Sstevel@tonic-gate {
141656deab07SRod Evans 	const char	*nname = fdp->fd_nname;
141756deab07SRod Evans 
14185aefb655Srie 	DBG_CALL(Dbg_libs_found(lml, nname, aflag));
14197c478bd9Sstevel@tonic-gate 	if ((lml->lm_flags & LML_FLG_TRC_SEARCH) &&
14207c478bd9Sstevel@tonic-gate 	    ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) {
14217c478bd9Sstevel@tonic-gate 		(void) printf(MSG_INTL(MSG_LDD_PTH_TRYING), nname, aflag ?
14227c478bd9Sstevel@tonic-gate 		    MSG_INTL(MSG_LDD_FIL_ALTER) : MSG_ORIG(MSG_STR_EMPTY));
14237c478bd9Sstevel@tonic-gate 	}
14247c478bd9Sstevel@tonic-gate 
14257c478bd9Sstevel@tonic-gate 	/*
14267c478bd9Sstevel@tonic-gate 	 * If we're being audited tell the audit library of the file we're about
14277c478bd9Sstevel@tonic-gate 	 * to go search for.  The audit library may offer an alternative
14287c478bd9Sstevel@tonic-gate 	 * dependency, or indicate that this dependency should be ignored.
14297c478bd9Sstevel@tonic-gate 	 */
143056deab07SRod Evans 	if ((lml->lm_tflags | AFLAGS(clmp)) & LML_TFLG_AUD_OBJSEARCH) {
14319aa23310Srie 		char	*aname;
14327c478bd9Sstevel@tonic-gate 
14339aa23310Srie 		if ((aname = audit_objsearch(clmp, nname,
143456deab07SRod Evans 		    (pdp->pd_flags & LA_SER_MASK))) == NULL) {
14357247f888Srie 			DBG_CALL(Dbg_audit_terminate(lml, nname));
14367c478bd9Sstevel@tonic-gate 			return (0);
14377247f888Srie 		}
14387247f888Srie 
143956deab07SRod Evans 		if (aname != nname) {
144056deab07SRod Evans 			fdp->fd_flags &= ~FLG_FD_SLASH;
144156deab07SRod Evans 			fdp->fd_nname = aname;
144256deab07SRod Evans 		}
14437c478bd9Sstevel@tonic-gate 	}
144456deab07SRod Evans 	return (file_open(0, lml, clmp, flags, fdp, rej, in_nfavl));
14457c478bd9Sstevel@tonic-gate }
14467c478bd9Sstevel@tonic-gate 
1447390b98b5Srie static int
find_file(Lm_list * lml,Rt_map * clmp,uint_t flags,Fdesc * fdp,Rej_desc * rej,Pdesc * pdp,Word * strhash,int * in_nfavl)144856deab07SRod Evans find_file(Lm_list *lml, Rt_map *clmp, uint_t flags, Fdesc *fdp, Rej_desc *rej,
144956deab07SRod Evans     Pdesc *pdp, Word *strhash, int *in_nfavl)
14507c478bd9Sstevel@tonic-gate {
14517c478bd9Sstevel@tonic-gate 	static Rtc_obj	Obj = { 0 };
1452aa736cbeSrie 	Rtc_obj		*dobj;
145356deab07SRod Evans 	const char	*oname = fdp->fd_oname;
145456deab07SRod Evans 	size_t		olen = strlen(oname);
14557c478bd9Sstevel@tonic-gate 
145656deab07SRod Evans 	if (pdp->pd_pname == NULL)
14577c478bd9Sstevel@tonic-gate 		return (0);
145856deab07SRod Evans 	if (pdp->pd_info) {
145956deab07SRod Evans 		dobj = (Rtc_obj *)pdp->pd_info;
14607c478bd9Sstevel@tonic-gate 		if ((dobj->co_flags &
14617c478bd9Sstevel@tonic-gate 		    (RTC_OBJ_NOEXIST | RTC_OBJ_ALTER)) == RTC_OBJ_NOEXIST)
14627c478bd9Sstevel@tonic-gate 			return (0);
14637c478bd9Sstevel@tonic-gate 	} else
146456deab07SRod Evans 		dobj = NULL;
14657c478bd9Sstevel@tonic-gate 
14667c478bd9Sstevel@tonic-gate 	/*
14677c478bd9Sstevel@tonic-gate 	 * If configuration information exists see if this directory/file
14687c478bd9Sstevel@tonic-gate 	 * combination exists.
14697c478bd9Sstevel@tonic-gate 	 */
14707c478bd9Sstevel@tonic-gate 	if ((rtld_flags & RT_FL_DIRCFG) &&
147156deab07SRod Evans 	    ((dobj == NULL) || (dobj->co_id != 0))) {
14727c478bd9Sstevel@tonic-gate 		Rtc_obj		*fobj;
147356deab07SRod Evans 		const char	*aname = NULL;
14747c478bd9Sstevel@tonic-gate 
14757c478bd9Sstevel@tonic-gate 		/*
147656deab07SRod Evans 		 * If this object descriptor has not yet been searched for in
147756deab07SRod Evans 		 * the configuration file go find it.
14787c478bd9Sstevel@tonic-gate 		 */
147956deab07SRod Evans 		if (dobj == NULL) {
148056deab07SRod Evans 			dobj = elf_config_ent(pdp->pd_pname,
148156deab07SRod Evans 			    (Word)elf_hash(pdp->pd_pname), 0, 0);
148256deab07SRod Evans 			if (dobj == NULL)
14837c478bd9Sstevel@tonic-gate 				dobj = &Obj;
148456deab07SRod Evans 			pdp->pd_info = (void *)dobj;
14857c478bd9Sstevel@tonic-gate 
14867c478bd9Sstevel@tonic-gate 			if ((dobj->co_flags & (RTC_OBJ_NOEXIST |
14877c478bd9Sstevel@tonic-gate 			    RTC_OBJ_ALTER)) == RTC_OBJ_NOEXIST)
14887c478bd9Sstevel@tonic-gate 				return (0);
14897c478bd9Sstevel@tonic-gate 		}
14907c478bd9Sstevel@tonic-gate 
14917c478bd9Sstevel@tonic-gate 		/*
14927c478bd9Sstevel@tonic-gate 		 * If we found a directory search for the file.
14937c478bd9Sstevel@tonic-gate 		 */
14947c478bd9Sstevel@tonic-gate 		if (dobj->co_id != 0) {
149567d74cc3SToomas Soome 			if (*strhash == 0)
149656deab07SRod Evans 				*strhash = (Word)elf_hash(oname);
149756deab07SRod Evans 			fobj = elf_config_ent(oname, *strhash,
149856deab07SRod Evans 			    dobj->co_id, &aname);
14997c478bd9Sstevel@tonic-gate 
15007c478bd9Sstevel@tonic-gate 			/*
15017c478bd9Sstevel@tonic-gate 			 * If this object specifically does not exist, or the
15027c478bd9Sstevel@tonic-gate 			 * object can't be found in a know-all-entries
15037c478bd9Sstevel@tonic-gate 			 * directory, continue looking.  If the object does
15047c478bd9Sstevel@tonic-gate 			 * exist determine if an alternative object exists.
15057c478bd9Sstevel@tonic-gate 			 */
150656deab07SRod Evans 			if (fobj == NULL) {
15077c478bd9Sstevel@tonic-gate 				if (dobj->co_flags & RTC_OBJ_ALLENTS)
15087c478bd9Sstevel@tonic-gate 					return (0);
15097c478bd9Sstevel@tonic-gate 			} else {
15107c478bd9Sstevel@tonic-gate 				if ((fobj->co_flags & (RTC_OBJ_NOEXIST |
15117c478bd9Sstevel@tonic-gate 				    RTC_OBJ_ALTER)) == RTC_OBJ_NOEXIST)
15127c478bd9Sstevel@tonic-gate 					return (0);
15137c478bd9Sstevel@tonic-gate 
15147c478bd9Sstevel@tonic-gate 				if ((fobj->co_flags & RTC_OBJ_ALTER) &&
15157c478bd9Sstevel@tonic-gate 				    (rtld_flags & RT_FL_OBJALT) &&
15167c478bd9Sstevel@tonic-gate 				    (lml == &lml_main)) {
15177c478bd9Sstevel@tonic-gate 					int	ret;
15187c478bd9Sstevel@tonic-gate 
151956deab07SRod Evans 					fdp->fd_flags |= FLG_FD_ALTER;
152056deab07SRod Evans 					fdp->fd_nname = aname;
152156deab07SRod Evans 
15227c478bd9Sstevel@tonic-gate 					/*
15237c478bd9Sstevel@tonic-gate 					 * Attempt to open the alternative path.
15247c478bd9Sstevel@tonic-gate 					 * If this fails, and the alternative is
15257c478bd9Sstevel@tonic-gate 					 * flagged as optional, fall through to
15267c478bd9Sstevel@tonic-gate 					 * open the original path.
15277c478bd9Sstevel@tonic-gate 					 */
152856deab07SRod Evans 					ret = _find_file(lml, clmp, flags, fdp,
152956deab07SRod Evans 					    rej, pdp, 1, in_nfavl);
15307c478bd9Sstevel@tonic-gate 					if (ret || ((fobj->co_flags &
15317c478bd9Sstevel@tonic-gate 					    RTC_OBJ_OPTINAL) == 0))
15327c478bd9Sstevel@tonic-gate 						return (ret);
15337c478bd9Sstevel@tonic-gate 
153456deab07SRod Evans 					fdp->fd_flags &= ~FLG_FD_ALTER;
15357c478bd9Sstevel@tonic-gate 				}
15367c478bd9Sstevel@tonic-gate 			}
15377c478bd9Sstevel@tonic-gate 		}
15387c478bd9Sstevel@tonic-gate 	}
15397c478bd9Sstevel@tonic-gate 
15407c478bd9Sstevel@tonic-gate 	/*
15417c478bd9Sstevel@tonic-gate 	 * Protect ourselves from building an invalid pathname.
15427c478bd9Sstevel@tonic-gate 	 */
154356deab07SRod Evans 	if ((olen + pdp->pd_plen + 1) >= PATH_MAX) {
154456deab07SRod Evans 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), oname,
15457c478bd9Sstevel@tonic-gate 		    strerror(ENAMETOOLONG));
1546fec04708SRichard Lowe 		return (0);
15477c478bd9Sstevel@tonic-gate 	}
154856deab07SRod Evans 	if ((fdp->fd_nname = (LM_GET_SO(clmp)(pdp->pd_pname, oname,
154956deab07SRod Evans 	    pdp->pd_plen, olen))) == NULL)
15507c478bd9Sstevel@tonic-gate 		return (0);
15517c478bd9Sstevel@tonic-gate 
155256deab07SRod Evans 	return (_find_file(lml, clmp, flags, fdp, rej, pdp, 0, in_nfavl));
15537c478bd9Sstevel@tonic-gate }
15547c478bd9Sstevel@tonic-gate 
155556deab07SRod Evans static Fct	*Vector[] = {
155656deab07SRod Evans 	&elf_fct,
155756deab07SRod Evans 	0
155856deab07SRod Evans };
155956deab07SRod Evans 
15607c478bd9Sstevel@tonic-gate /*
156156deab07SRod Evans  * Remap the first page of a file to provide a better diagnostic as to why
156256deab07SRod Evans  * an mmapobj(2) operation on this file failed.  Sadly, mmapobj(), and all
156356deab07SRod Evans  * system calls for that matter, only pass back a generic failure in errno.
156456deab07SRod Evans  * Hopefully one day this will be improved, but in the mean time we repeat
156556deab07SRod Evans  * the kernels ELF verification to try and provide more detailed information.
15667c478bd9Sstevel@tonic-gate  */
156756deab07SRod Evans static int
map_fail(Fdesc * fdp,size_t fsize,const char * name,int fd,Rej_desc * rej)156856deab07SRod Evans map_fail(Fdesc *fdp, size_t fsize, const char *name, int fd, Rej_desc *rej)
15697c478bd9Sstevel@tonic-gate {
157056deab07SRod Evans 	caddr_t	addr;
157156deab07SRod Evans 	int	vnum;
157256deab07SRod Evans 	size_t	size;
15737c478bd9Sstevel@tonic-gate 
15747c478bd9Sstevel@tonic-gate 	/*
157556deab07SRod Evans 	 * Use the original file size to determine what to map, and catch the
157656deab07SRod Evans 	 * obvious error of a zero sized file.
15777c478bd9Sstevel@tonic-gate 	 */
157856deab07SRod Evans 	if (fsize == 0) {
157956deab07SRod Evans 		rej->rej_type = SGS_REJ_UNKFILE;
158056deab07SRod Evans 		return (1);
158156deab07SRod Evans 	} else if (fsize < syspagsz)
158256deab07SRod Evans 		size = fsize;
158356deab07SRod Evans 	else
158456deab07SRod Evans 		size = syspagsz;
158556deab07SRod Evans 
158656deab07SRod Evans 	if ((addr = mmap(0, size, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED)
158756deab07SRod Evans 		return (0);
158856deab07SRod Evans 
158956deab07SRod Evans 	rej->rej_type = 0;
15907c478bd9Sstevel@tonic-gate 
15917c478bd9Sstevel@tonic-gate 	/*
159256deab07SRod Evans 	 * Validate the file against each supported file type.  Should a
159356deab07SRod Evans 	 * characteristic of the file be found invalid for this platform, a
159456deab07SRod Evans 	 * rejection message will have been recorded.
15957c478bd9Sstevel@tonic-gate 	 */
159656deab07SRod Evans 	for (vnum = 0; Vector[vnum]; vnum++) {
159756deab07SRod Evans 		if (((Vector[vnum]->fct_verify_file)(addr, size,
159856deab07SRod Evans 		    fdp, name, rej) == 0) && rej->rej_type)
159956deab07SRod Evans 			break;
160056deab07SRod Evans 	}
16017c478bd9Sstevel@tonic-gate 
160256deab07SRod Evans 	/*
160356deab07SRod Evans 	 * If no rejection message has been recorded, then this is simply an
160456deab07SRod Evans 	 * unknown file type.
160556deab07SRod Evans 	 */
160656deab07SRod Evans 	if (rej->rej_type == 0)
160756deab07SRod Evans 		rej->rej_type = SGS_REJ_UNKFILE;
160856deab07SRod Evans 
160956deab07SRod Evans 	(void) munmap(addr, size);
161056deab07SRod Evans 	return (1);
161156deab07SRod Evans }
161256deab07SRod Evans 
161356deab07SRod Evans /*
161456deab07SRod Evans  * Unmap a file.
161556deab07SRod Evans  */
161656deab07SRod Evans void
unmap_obj(mmapobj_result_t * mpp,uint_t mapnum)161756deab07SRod Evans unmap_obj(mmapobj_result_t *mpp, uint_t mapnum)
161856deab07SRod Evans {
161956deab07SRod Evans 	uint_t	num;
162056deab07SRod Evans 
162156deab07SRod Evans 	for (num = 0; num < mapnum; num++) {
162256deab07SRod Evans 		/* LINTED */
162356deab07SRod Evans 		(void) munmap((void *)(uintptr_t)mpp[num].mr_addr,
162456deab07SRod Evans 		    mpp[num].mr_msize);
162556deab07SRod Evans 	}
162620272c2eSAli Bahrami 	cnt_unmap++;
162756deab07SRod Evans }
162856deab07SRod Evans 
162956deab07SRod Evans /*
163056deab07SRod Evans  * Map a file.
163156deab07SRod Evans  */
163256deab07SRod Evans Fct *
map_obj(Lm_list * lml,Fdesc * fdp,size_t fsize,const char * name,int fd,Rej_desc * rej)163356deab07SRod Evans map_obj(Lm_list *lml, Fdesc *fdp, size_t fsize, const char *name, int fd,
163456deab07SRod Evans     Rej_desc *rej)
163556deab07SRod Evans {
163656deab07SRod Evans 	static mmapobj_result_t	*smpp = NULL;
163756deab07SRod Evans 	static uint_t		smapnum;
163856deab07SRod Evans 	mmapobj_result_t	*mpp;
163956deab07SRod Evans 	uint_t			mnum, mapnum, mflags;
164056deab07SRod Evans 	void			*padding;
16417c478bd9Sstevel@tonic-gate 
16427c478bd9Sstevel@tonic-gate 	/*
164356deab07SRod Evans 	 * Allocate an initial mapping array.  The initial size should be large
164456deab07SRod Evans 	 * enough to handle the normal ELF objects we come across.
16457c478bd9Sstevel@tonic-gate 	 */
164656deab07SRod Evans 	if (smpp == NULL) {
164756deab07SRod Evans 		smpp = malloc(sizeof (mmapobj_result_t) * MMAPFD_NUM);
164856deab07SRod Evans 		if (smpp == NULL)
164956deab07SRod Evans 			return (NULL);
165056deab07SRod Evans 		smapnum = MMAPFD_NUM;
165156deab07SRod Evans 	}
16527c478bd9Sstevel@tonic-gate 
16537c478bd9Sstevel@tonic-gate 	/*
165456deab07SRod Evans 	 * If object padding is required, set the necessary flags.
165556deab07SRod Evans 	 */
165656deab07SRod Evans 	if (r_debug.rtd_objpad) {
165756deab07SRod Evans 		mflags = MMOBJ_INTERPRET | MMOBJ_PADDING;
165856deab07SRod Evans 		padding = &r_debug.rtd_objpad;
165956deab07SRod Evans 	} else {
166056deab07SRod Evans 		mflags = MMOBJ_INTERPRET;
166156deab07SRod Evans 		padding = NULL;
166256deab07SRod Evans 	}
166356deab07SRod Evans 
166456deab07SRod Evans 	/*
166556deab07SRod Evans 	 * Map the file.  If the number of mappings required by this file
166656deab07SRod Evans 	 * exceeds the present mapping structure, an error indicating the
166756deab07SRod Evans 	 * return data is too big is returned.  Bail on any other error.
166856deab07SRod Evans 	 */
166956deab07SRod Evans 	mapnum = smapnum;
167056deab07SRod Evans 	if (mmapobj(fd, mflags, smpp, &mapnum, padding) == -1) {
167156deab07SRod Evans 		if (errno != E2BIG) {
167256deab07SRod Evans 			int	err = errno;
167356deab07SRod Evans 
167456deab07SRod Evans 			/*
167556deab07SRod Evans 			 * An unsupported error indicates that there's something
167656deab07SRod Evans 			 * incompatible with this ELF file, and the process that
167756deab07SRod Evans 			 * is already running.  Map the first page of the file
167856deab07SRod Evans 			 * and see if we can generate a better error message.
167956deab07SRod Evans 			 */
168056deab07SRod Evans 			if ((errno == ENOTSUP) && map_fail(fdp, fsize, name,
168156deab07SRod Evans 			    fd, rej))
168256deab07SRod Evans 				return (NULL);
168356deab07SRod Evans 
168456deab07SRod Evans 			rej->rej_type = SGS_REJ_STR;
168556deab07SRod Evans 			rej->rej_str = strerror(err);
168637ffaf83SRod Evans 			return (NULL);
16877c478bd9Sstevel@tonic-gate 		}
168856deab07SRod Evans 
168956deab07SRod Evans 		/*
169056deab07SRod Evans 		 * The mapping requirement exceeds the present mapping
169156deab07SRod Evans 		 * structure, however the number of mapping required is
169256deab07SRod Evans 		 * available in the mapping number.
169356deab07SRod Evans 		 */
169456deab07SRod Evans 		free((void *)smpp);
169556deab07SRod Evans 		if ((smpp = malloc(sizeof (mmapobj_result_t) * mapnum)) == NULL)
169656deab07SRod Evans 			return (NULL);
169756deab07SRod Evans 		smapnum = mapnum;
169856deab07SRod Evans 
169956deab07SRod Evans 		/*
170056deab07SRod Evans 		 * With the appropriate mapping structure, try the mapping
170156deab07SRod Evans 		 * request again.
170256deab07SRod Evans 		 */
170356deab07SRod Evans 		if (mmapobj(fd, mflags, smpp, &mapnum, padding) == -1) {
170456deab07SRod Evans 			rej->rej_type = SGS_REJ_STR;
170556deab07SRod Evans 			rej->rej_str = strerror(errno);
170637ffaf83SRod Evans 			return (NULL);
17077c478bd9Sstevel@tonic-gate 		}
170856deab07SRod Evans 	}
170956deab07SRod Evans 	ASSERT(mapnum != 0);
171056deab07SRod Evans 
171156deab07SRod Evans 	/*
171256deab07SRod Evans 	 * Traverse the mappings in search of a file type ld.so.1 can process.
171356deab07SRod Evans 	 * If the file type is verified as one ld.so.1 can process, retain the
171456deab07SRod Evans 	 * mapping information, and the number of mappings this object uses,
171556deab07SRod Evans 	 * and clear the static mapping pointer for the next map_obj() use of
171656deab07SRod Evans 	 * mmapobj().
171756deab07SRod Evans 	 */
171856deab07SRod Evans 	DBG_CALL(Dbg_file_mmapobj(lml, name, smpp, mapnum));
171920272c2eSAli Bahrami 	cnt_map++;
172056deab07SRod Evans 
172156deab07SRod Evans 	for (mnum = 0, mpp = smpp; mnum < mapnum; mnum++, mpp++) {
172256deab07SRod Evans 		uint_t	flags = (mpp->mr_flags & MR_TYPE_MASK);
172356deab07SRod Evans 		Fct	*fptr = NULL;
172456deab07SRod Evans 
172556deab07SRod Evans 		if (flags == MR_HDR_ELF) {
172656deab07SRod Evans 			fptr = elf_verify((mpp->mr_addr + mpp->mr_offset),
172756deab07SRod Evans 			    mpp->mr_fsize, fdp, name, rej);
172856deab07SRod Evans 		}
172956deab07SRod Evans 		if (fptr) {
173056deab07SRod Evans 			fdp->fd_mapn = mapnum;
173156deab07SRod Evans 			fdp->fd_mapp = smpp;
173256deab07SRod Evans 
173356deab07SRod Evans 			smpp = NULL;
173456deab07SRod Evans 
173556deab07SRod Evans 			return (fptr);
173656deab07SRod Evans 		}
173756deab07SRod Evans 	}
173856deab07SRod Evans 
173956deab07SRod Evans 	/*
174056deab07SRod Evans 	 * If the mapped file is inappropriate, indicate that the file type is
174156deab07SRod Evans 	 * unknown, and free the mapping.
174256deab07SRod Evans 	 */
174356deab07SRod Evans 	if (rej->rej_type == 0)
174456deab07SRod Evans 		rej->rej_type = SGS_REJ_UNKFILE;
174556deab07SRod Evans 	unmap_obj(smpp, mapnum);
174656deab07SRod Evans 
174756deab07SRod Evans 	return (NULL);
174856deab07SRod Evans }
174956deab07SRod Evans 
175056deab07SRod Evans /*
175156deab07SRod Evans  * A unique file has been opened.  Create a link-map to represent it, and
175256deab07SRod Evans  * process the various names by which it can be referenced.
175356deab07SRod Evans  */
175456deab07SRod Evans Rt_map *
load_file(Lm_list * lml,Aliste lmco,Rt_map * clmp,Fdesc * fdp,int * in_nfavl)17552020b2b6SRod Evans load_file(Lm_list *lml, Aliste lmco, Rt_map *clmp, Fdesc *fdp, int *in_nfavl)
175656deab07SRod Evans {
175756deab07SRod Evans 	mmapobj_result_t	*fpmpp = NULL, *fmpp = NULL, *lpmpp, *lmpp;
175856deab07SRod Evans 	mmapobj_result_t	*hmpp, *mpp, *ompp = fdp->fd_mapp;
175956deab07SRod Evans 	uint_t			mnum, omapnum = fdp->fd_mapn;
176056deab07SRod Evans 	const char		*nname = fdp->fd_nname;
176156deab07SRod Evans 	Rt_map			*nlmp;
176256deab07SRod Evans 	Ehdr			*ehdr = NULL;
176356deab07SRod Evans 
176456deab07SRod Evans 	/*
176556deab07SRod Evans 	 * Traverse the mappings for the input file to capture generic mapping
176656deab07SRod Evans 	 * information, and create a link-map to represent the file.
176756deab07SRod Evans 	 */
176856deab07SRod Evans 	for (mnum = 0, mpp = ompp; mnum < omapnum; mnum++, mpp++) {
176956deab07SRod Evans 		uint_t	flags = (mpp->mr_flags & MR_TYPE_MASK);
17703dbfc803SRod Evans 
17713dbfc803SRod Evans 		/*
177256deab07SRod Evans 		 * Keep track of the first and last mappings that may include
177356deab07SRod Evans 		 * padding.
177456deab07SRod Evans 		 */
177556deab07SRod Evans 		if (fpmpp == NULL)
177656deab07SRod Evans 			fpmpp = mpp;
177756deab07SRod Evans 		lpmpp = mpp;
177856deab07SRod Evans 
177956deab07SRod Evans 		/*
178056deab07SRod Evans 		 * Keep track of the first and last mappings that do not include
178156deab07SRod Evans 		 * padding.
178256deab07SRod Evans 		 */
178356deab07SRod Evans 		if (flags != MR_PADDING) {
178456deab07SRod Evans 			if (fmpp == NULL)
178556deab07SRod Evans 				fmpp = mpp;
178656deab07SRod Evans 			lmpp = mpp;
17873dbfc803SRod Evans 		}
178856deab07SRod Evans 		if (flags == MR_HDR_ELF) {
178956deab07SRod Evans 			/* LINTED */
179056deab07SRod Evans 			ehdr = (Ehdr *)(mpp->mr_addr + mpp->mr_offset);
179156deab07SRod Evans 			hmpp = mpp;
1792fec04708SRichard Lowe 		}
179356deab07SRod Evans 	}
179456deab07SRod Evans 
179556deab07SRod Evans 	/*
179656deab07SRod Evans 	 * The only ELF files we can handle are ET_EXEC, ET_DYN, and ET_REL.
179756deab07SRod Evans 	 *
179856deab07SRod Evans 	 * ET_REL must be processed by ld(1) to create an in-memory ET_DYN.
179956deab07SRod Evans 	 * The initial processing carried out by elf_obj_file() creates a
180056deab07SRod Evans 	 * temporary link-map, that acts as a place holder, until the objects
180156deab07SRod Evans 	 * processing is finished with elf_obj_fini().
180256deab07SRod Evans 	 */
180356deab07SRod Evans 	if (ehdr && (ehdr->e_type == ET_REL)) {
18042020b2b6SRod Evans 		if ((nlmp = elf_obj_file(lml, lmco, clmp, nname, hmpp, ompp,
180556deab07SRod Evans 		    omapnum)) == NULL)
180656deab07SRod Evans 			return (nlmp);
180756deab07SRod Evans 	} else {
180856deab07SRod Evans 		Addr	addr;
180956deab07SRod Evans 		size_t	msize;
181056deab07SRod Evans 
181156deab07SRod Evans 		/*
181256deab07SRod Evans 		 * The size of the total reservation, and the padding range,
181356deab07SRod Evans 		 * are a historic artifact required by debuggers.  Although
181456deab07SRod Evans 		 * these values express the range of the associated mappings,
181556deab07SRod Evans 		 * there can be holes between segments (in which small objects
181656deab07SRod Evans 		 * could be mapped).  Anyone who needs to verify offsets
181756deab07SRod Evans 		 * against segments should analyze all the object mappings,
181856deab07SRod Evans 		 * rather than relying on these address ranges.
181956deab07SRod Evans 		 */
182056deab07SRod Evans 		addr = (Addr)(hmpp->mr_addr + hmpp->mr_offset);
182156deab07SRod Evans 		msize = lmpp->mr_addr + lmpp->mr_msize - fmpp->mr_addr;
182256deab07SRod Evans 
182356deab07SRod Evans 		if ((nlmp = ((fdp->fd_ftp)->fct_new_lmp)(lml, lmco, fdp, addr,
18242020b2b6SRod Evans 		    msize, NULL, clmp, in_nfavl)) == NULL)
182556deab07SRod Evans 			return (NULL);
182656deab07SRod Evans 
182756deab07SRod Evans 		/*
182856deab07SRod Evans 		 * Save generic mapping information.
182956deab07SRod Evans 		 */
183056deab07SRod Evans 		MMAPS(nlmp) = ompp;
183156deab07SRod Evans 		MMAPCNT(nlmp) = omapnum;
183256deab07SRod Evans 		PADSTART(nlmp) = (ulong_t)fpmpp->mr_addr;
183356deab07SRod Evans 		PADIMLEN(nlmp) = lpmpp->mr_addr + lpmpp->mr_msize -
183456deab07SRod Evans 		    fpmpp->mr_addr;
183556deab07SRod Evans 	}
183656deab07SRod Evans 
183756deab07SRod Evans 	/*
183856deab07SRod Evans 	 * Save the dev/inode information for later comparisons, and identify
183956deab07SRod Evans 	 * this as a new object.
184056deab07SRod Evans 	 */
184156deab07SRod Evans 	STDEV(nlmp) = fdp->fd_dev;
184256deab07SRod Evans 	STINO(nlmp) = fdp->fd_ino;
184356deab07SRod Evans 	FLAGS(nlmp) |= FLG_RT_NEWLOAD;
184456deab07SRod Evans 
184556deab07SRod Evans 	/*
184656deab07SRod Evans 	 * If this is ELF relocatable object, we're done for now.
184756deab07SRod Evans 	 */
184856deab07SRod Evans 	if (ehdr && (ehdr->e_type == ET_REL))
184956deab07SRod Evans 		return (nlmp);
185056deab07SRod Evans 
185156deab07SRod Evans 	/*
185256deab07SRod Evans 	 * Insert the names of this link-map into the FullPathNode AVL tree.
185356deab07SRod Evans 	 * Save both the NAME() and PATHNAME() if the names differ.
185456deab07SRod Evans 	 */
185556deab07SRod Evans 	(void) fullpath(nlmp, fdp);
185656deab07SRod Evans 
185756deab07SRod Evans 	if ((NAME(nlmp)[0] == '/') && (fpavl_insert(lml, nlmp, NAME(nlmp),
185856deab07SRod Evans 	    fdp->fd_avlwhere) == 0)) {
18592020b2b6SRod Evans 		remove_so(lml, nlmp, clmp);
186056deab07SRod Evans 		return (NULL);
186156deab07SRod Evans 	}
186256deab07SRod Evans 	if (((NAME(nlmp)[0] != '/') || (NAME(nlmp) != PATHNAME(nlmp))) &&
186356deab07SRod Evans 	    (fpavl_insert(lml, nlmp, PATHNAME(nlmp), 0) == 0)) {
18642020b2b6SRod Evans 		remove_so(lml, nlmp, clmp);
186556deab07SRod Evans 		return (NULL);
186656deab07SRod Evans 	}
186756deab07SRod Evans 
186856deab07SRod Evans 	/*
186956deab07SRod Evans 	 * If this is a secure application, record any full path name directory
187056deab07SRod Evans 	 * in which this dependency has been found.  This directory can be
187156deab07SRod Evans 	 * deemed safe (as we've already found a dependency here).  This
187256deab07SRod Evans 	 * recording provides a fall-back should another objects $ORIGIN
187356deab07SRod Evans 	 * definition expands to this directory, an expansion that would
187456deab07SRod Evans 	 * ordinarily be deemed insecure.
187556deab07SRod Evans 	 */
187656deab07SRod Evans 	if (rtld_flags & RT_FL_SECURE) {
187756deab07SRod Evans 		if (NAME(nlmp)[0] == '/')
187856deab07SRod Evans 			spavl_insert(NAME(nlmp));
187956deab07SRod Evans 		if ((NAME(nlmp) != PATHNAME(nlmp)) &&
188056deab07SRod Evans 		    (PATHNAME(nlmp)[0] == '/'))
188156deab07SRod Evans 			spavl_insert(PATHNAME(nlmp));
18827c478bd9Sstevel@tonic-gate 	}
18837c478bd9Sstevel@tonic-gate 
18847c478bd9Sstevel@tonic-gate 	/*
18857c478bd9Sstevel@tonic-gate 	 * If we're processing an alternative object reset the original name
18867c478bd9Sstevel@tonic-gate 	 * for possible $ORIGIN processing.
18877c478bd9Sstevel@tonic-gate 	 */
188856deab07SRod Evans 	if (fdp->fd_flags & FLG_FD_ALTER) {
188956deab07SRod Evans 		const char	*odir, *ndir;
18907c478bd9Sstevel@tonic-gate 		size_t		olen;
18917c478bd9Sstevel@tonic-gate 
18927c478bd9Sstevel@tonic-gate 		FLAGS(nlmp) |= FLG_RT_ALTER;
18937c478bd9Sstevel@tonic-gate 
18947c478bd9Sstevel@tonic-gate 		/*
18957c478bd9Sstevel@tonic-gate 		 * If we were given a pathname containing a slash then the
18967c478bd9Sstevel@tonic-gate 		 * original name is still in oname.  Otherwise the original
18977c478bd9Sstevel@tonic-gate 		 * directory is in dir->p_name (which is all we need for
18987c478bd9Sstevel@tonic-gate 		 * $ORIGIN).
18997c478bd9Sstevel@tonic-gate 		 */
190056deab07SRod Evans 		if (fdp->fd_flags & FLG_FD_SLASH) {
19017c478bd9Sstevel@tonic-gate 			char	*ofil;
19027c478bd9Sstevel@tonic-gate 
190356deab07SRod Evans 			odir = fdp->fd_oname;
190456deab07SRod Evans 			ofil = strrchr(fdp->fd_oname, '/');
19057c478bd9Sstevel@tonic-gate 			olen = ofil - odir + 1;
19067c478bd9Sstevel@tonic-gate 		} else {
190756deab07SRod Evans 			odir = fdp->fd_odir;
19087c478bd9Sstevel@tonic-gate 			olen = strlen(odir) + 1;
19097c478bd9Sstevel@tonic-gate 		}
191056deab07SRod Evans 		if ((ndir = stravl_insert(odir, 0, olen, 1)) == NULL) {
19112020b2b6SRod Evans 			remove_so(lml, nlmp, clmp);
191237ffaf83SRod Evans 			return (NULL);
19137c478bd9Sstevel@tonic-gate 		}
19147c478bd9Sstevel@tonic-gate 		ORIGNAME(nlmp) = ndir;
191556deab07SRod Evans 		DIRSZ(nlmp) = --olen;
19167c478bd9Sstevel@tonic-gate 	}
19177c478bd9Sstevel@tonic-gate 
19187c478bd9Sstevel@tonic-gate 	return (nlmp);
19197c478bd9Sstevel@tonic-gate }
19207c478bd9Sstevel@tonic-gate 
19217c478bd9Sstevel@tonic-gate /*
19227c478bd9Sstevel@tonic-gate  * This function loads the named file and returns a pointer to its link map.
19237c478bd9Sstevel@tonic-gate  * It is assumed that the caller has already checked that the file is not
19247c478bd9Sstevel@tonic-gate  * already loaded before calling this function (refer is_so_loaded()).
19257c478bd9Sstevel@tonic-gate  * Find and open the file, map it into memory, add it to the end of the list
19267c478bd9Sstevel@tonic-gate  * of link maps and return a pointer to the new link map.  Return 0 on error.
19277c478bd9Sstevel@tonic-gate  */
19287c478bd9Sstevel@tonic-gate static Rt_map *
load_so(Lm_list * lml,Aliste lmco,Rt_map * clmp,uint_t flags,Fdesc * fdp,Rej_desc * rej,int * in_nfavl)192956deab07SRod Evans load_so(Lm_list *lml, Aliste lmco, Rt_map *clmp, uint_t flags,
193056deab07SRod Evans     Fdesc *fdp, Rej_desc *rej, int *in_nfavl)
19317c478bd9Sstevel@tonic-gate {
193256deab07SRod Evans 	const char	*oname = fdp->fd_oname;
193356deab07SRod Evans 	Pdesc		*pdp;
19347c478bd9Sstevel@tonic-gate 
19357c478bd9Sstevel@tonic-gate 	/*
193656deab07SRod Evans 	 * If this path name hasn't already been identified as containing a
193756deab07SRod Evans 	 * slash, check the path name.  Most paths have been constructed
193856deab07SRod Evans 	 * through appending a file name to a search path, and/or have been
193956deab07SRod Evans 	 * inspected by expand(), and thus have a slash.  However, we can
194056deab07SRod Evans 	 * receive path names via auditors or configuration files, and thus
194156deab07SRod Evans 	 * an evaluation here catches these instances.
19427c478bd9Sstevel@tonic-gate 	 */
194356deab07SRod Evans 	if ((fdp->fd_flags & FLG_FD_SLASH) == 0) {
19447c478bd9Sstevel@tonic-gate 		const char	*str;
19457c478bd9Sstevel@tonic-gate 
19467c478bd9Sstevel@tonic-gate 		for (str = oname; *str; str++) {
19477c478bd9Sstevel@tonic-gate 			if (*str == '/') {
194856deab07SRod Evans 				fdp->fd_flags |= FLG_FD_SLASH;
19497c478bd9Sstevel@tonic-gate 				break;
19507c478bd9Sstevel@tonic-gate 			}
19517c478bd9Sstevel@tonic-gate 		}
19527c478bd9Sstevel@tonic-gate 	}
19537c478bd9Sstevel@tonic-gate 
19547c478bd9Sstevel@tonic-gate 	/*
19557c478bd9Sstevel@tonic-gate 	 * If we are passed a 'null' link-map this means that this is the first
19567c478bd9Sstevel@tonic-gate 	 * object to be loaded on this link-map list.  In that case we set the
19577c478bd9Sstevel@tonic-gate 	 * link-map to ld.so.1's link-map.
19587c478bd9Sstevel@tonic-gate 	 *
19597c478bd9Sstevel@tonic-gate 	 * This link-map is referenced to determine what lookup rules to use
19607c478bd9Sstevel@tonic-gate 	 * when searching for files.  By using ld.so.1's we are defaulting to
19617c478bd9Sstevel@tonic-gate 	 * ELF look-up rules.
19627c478bd9Sstevel@tonic-gate 	 *
19637c478bd9Sstevel@tonic-gate 	 * Note: This case happens when loading the first object onto
19647c478bd9Sstevel@tonic-gate 	 *	 the plt_tracing link-map.
19657c478bd9Sstevel@tonic-gate 	 */
19667c478bd9Sstevel@tonic-gate 	if (clmp == 0)
19677c478bd9Sstevel@tonic-gate 		clmp = lml_rtld.lm_head;
19687c478bd9Sstevel@tonic-gate 
19697c478bd9Sstevel@tonic-gate 	/*
197008278a5eSRod Evans 	 * If this path resulted from a $CAPABILITY specification, then the
197108278a5eSRod Evans 	 * best capability object has already been establish, and is available
197208278a5eSRod Evans 	 * in the calling file descriptor.  Perform some minor book-keeping so
197308278a5eSRod Evans 	 * that we can fall through into common code.
19747c478bd9Sstevel@tonic-gate 	 */
197508278a5eSRod Evans 	if (flags & FLG_RT_CAP) {
19767c478bd9Sstevel@tonic-gate 		/*
1977fb1354edSrie 		 * If this object is already loaded, we're done.
19787c478bd9Sstevel@tonic-gate 		 */
197956deab07SRod Evans 		if (fdp->fd_lmp)
198056deab07SRod Evans 			return (fdp->fd_lmp);
19817c478bd9Sstevel@tonic-gate 
1982fb1354edSrie 		/*
1983fb1354edSrie 		 * Obtain the avl index for this object.
1984fb1354edSrie 		 */
198556deab07SRod Evans 		(void) fpavl_recorded(lml, fdp->fd_nname, 0,
198656deab07SRod Evans 		    &(fdp->fd_avlwhere));
19874464de07SAli Bahrami 
198856deab07SRod Evans 	} else if (fdp->fd_flags & FLG_FD_SLASH) {
19897c478bd9Sstevel@tonic-gate 		Rej_desc	_rej = { 0 };
19907c478bd9Sstevel@tonic-gate 
199156deab07SRod Evans 		if (find_path(lml, clmp, flags, fdp, &_rej, in_nfavl) == 0) {
199231fdd7caSab 			rejection_inherit(rej, &_rej);
199337ffaf83SRod Evans 			return (NULL);
19947c478bd9Sstevel@tonic-gate 		}
19957c478bd9Sstevel@tonic-gate 
19967c478bd9Sstevel@tonic-gate 		/*
19977c478bd9Sstevel@tonic-gate 		 * If this object is already loaded, we're done.
19987c478bd9Sstevel@tonic-gate 		 */
199956deab07SRod Evans 		if (fdp->fd_lmp)
200056deab07SRod Evans 			return (fdp->fd_lmp);
20017c478bd9Sstevel@tonic-gate 
20027c478bd9Sstevel@tonic-gate 	} else {
20037c478bd9Sstevel@tonic-gate 		/*
20047c478bd9Sstevel@tonic-gate 		 * No '/' - for each directory on list, make a pathname using
20057c478bd9Sstevel@tonic-gate 		 * that directory and filename and try to open that file.
20067c478bd9Sstevel@tonic-gate 		 */
200756deab07SRod Evans 		Spath_desc	sd = { search_rules, NULL, 0 };
20087c478bd9Sstevel@tonic-gate 		Word		strhash = 0;
200956deab07SRod Evans 		int		found = 0;
201056deab07SRod Evans 
20117c478bd9Sstevel@tonic-gate 		/*
201256deab07SRod Evans 		 * Traverse the search path lists, creating full pathnames and
201356deab07SRod Evans 		 * attempt to load each path.
20147c478bd9Sstevel@tonic-gate 		 */
201556deab07SRod Evans 		for (pdp = get_next_dir(&sd, clmp, flags); pdp;
201656deab07SRod Evans 		    pdp = get_next_dir(&sd, clmp, flags)) {
20177c478bd9Sstevel@tonic-gate 			Rej_desc	_rej = { 0 };
201856deab07SRod Evans 			Fdesc		fd = { 0 };
20197c478bd9Sstevel@tonic-gate 
20209aa23310Srie 			/*
20219aa23310Srie 			 * Under debugging, duplicate path name entries are
20229aa23310Srie 			 * tagged but remain part of the search path list so
20239aa23310Srie 			 * that they can be diagnosed under "unused" processing.
20249aa23310Srie 			 * Skip these entries, as this path would have already
20259aa23310Srie 			 * been attempted.
20269aa23310Srie 			 */
202756deab07SRod Evans 			if (pdp->pd_flags & PD_FLG_DUPLICAT)
20289aa23310Srie 				continue;
20299aa23310Srie 
203056deab07SRod Evans 			fd = *fdp;
203156deab07SRod Evans 
20327c478bd9Sstevel@tonic-gate 			/*
20337c478bd9Sstevel@tonic-gate 			 * Try and locate this file.  Make sure to clean up
20347c478bd9Sstevel@tonic-gate 			 * any rejection information should the file have
20357c478bd9Sstevel@tonic-gate 			 * been found, but not appropriate.
20367c478bd9Sstevel@tonic-gate 			 */
203756deab07SRod Evans 			if (find_file(lml, clmp, flags, &fd, &_rej, pdp,
203856deab07SRod Evans 			    &strhash, in_nfavl) == 0) {
203931fdd7caSab 				rejection_inherit(rej, &_rej);
20407c478bd9Sstevel@tonic-gate 				continue;
20417c478bd9Sstevel@tonic-gate 			}
20427c478bd9Sstevel@tonic-gate 
20439aa23310Srie 			/*
20449aa23310Srie 			 * Indicate that this search path has been used.  If
20459aa23310Srie 			 * this is an LD_LIBRARY_PATH setting, ignore any use
20469aa23310Srie 			 * by ld.so.1 itself.
20479aa23310Srie 			 */
204856deab07SRod Evans 			if (((pdp->pd_flags & LA_SER_LIBPATH) == 0) ||
20499aa23310Srie 			    ((lml->lm_flags & LML_FLG_RTLDLM) == 0))
205056deab07SRod Evans 				pdp->pd_flags |= PD_FLG_USED;
20519aa23310Srie 
20527c478bd9Sstevel@tonic-gate 			/*
20537c478bd9Sstevel@tonic-gate 			 * If this object is already loaded, we're done.
20547c478bd9Sstevel@tonic-gate 			 */
205556deab07SRod Evans 			*fdp = fd;
205656deab07SRod Evans 			if (fdp->fd_lmp)
205756deab07SRod Evans 				return (fdp->fd_lmp);
20587c478bd9Sstevel@tonic-gate 
205956deab07SRod Evans 			fdp->fd_odir = pdp->pd_pname;
206056deab07SRod Evans 			found = 1;
20617c478bd9Sstevel@tonic-gate 			break;
20627c478bd9Sstevel@tonic-gate 		}
20637c478bd9Sstevel@tonic-gate 
20647c478bd9Sstevel@tonic-gate 		/*
20657c478bd9Sstevel@tonic-gate 		 * If the file couldn't be loaded, do another comparison of
20667c478bd9Sstevel@tonic-gate 		 * loaded files using just the basename.  This catches folks
20677c478bd9Sstevel@tonic-gate 		 * who may have loaded multiple full pathname files (possibly
20687c478bd9Sstevel@tonic-gate 		 * from setxid applications) to satisfy dependency relationships
20697c478bd9Sstevel@tonic-gate 		 * (i.e., a file might have a dependency on foo.so.1 which has
20707c478bd9Sstevel@tonic-gate 		 * already been opened using its full pathname).
20717c478bd9Sstevel@tonic-gate 		 */
207256deab07SRod Evans 		if (found == 0)
20739aa23310Srie 			return (is_so_loaded(lml, oname, in_nfavl));
20747c478bd9Sstevel@tonic-gate 	}
20757c478bd9Sstevel@tonic-gate 
20767c478bd9Sstevel@tonic-gate 	/*
207708278a5eSRod Evans 	 * Trace that this successfully opened file is about to be processed.
207808278a5eSRod Evans 	 * Note, as part of processing a family of hardware capabilities filtees
207908278a5eSRod Evans 	 * a number of candidates may have been opened and mapped to determine
208008278a5eSRod Evans 	 * their capability requirements.  At this point we've decided which
208108278a5eSRod Evans 	 * of the candidates to use.
208208278a5eSRod Evans 	 */
208308278a5eSRod Evans 	if (lml->lm_flags & LML_FLG_TRC_ENABLE) {
208408278a5eSRod Evans 		trace_so(clmp, 0, fdp->fd_oname, fdp->fd_nname,
208508278a5eSRod Evans 		    (fdp->fd_flags & FLG_FD_ALTER), 0);
208608278a5eSRod Evans 	}
208708278a5eSRod Evans 
208808278a5eSRod Evans 	/*
208908278a5eSRod Evans 	 * Finish mapping the file and return the link-map descriptor.
20907c478bd9Sstevel@tonic-gate 	 */
20912020b2b6SRod Evans 	return (load_file(lml, lmco, clmp, fdp, in_nfavl));
20927c478bd9Sstevel@tonic-gate }
20937c478bd9Sstevel@tonic-gate 
20947c478bd9Sstevel@tonic-gate /*
209556deab07SRod Evans  * Trace an attempt to load an object, and seed the originating name.
20967c478bd9Sstevel@tonic-gate  */
209756deab07SRod Evans const char *
load_trace(Lm_list * lml,Pdesc * pdp,Rt_map * clmp,Fdesc * fdp)209856deab07SRod Evans load_trace(Lm_list *lml, Pdesc *pdp, Rt_map *clmp, Fdesc *fdp)
20997c478bd9Sstevel@tonic-gate {
210056deab07SRod Evans 	const char	*name = pdp->pd_pname;
21017247f888Srie 
21022020b2b6SRod Evans 	DBG_CALL(Dbg_libs_find(lml, name));
21032020b2b6SRod Evans 
21047c478bd9Sstevel@tonic-gate 	/*
21057c478bd9Sstevel@tonic-gate 	 * First generate any ldd(1) diagnostics.
21067c478bd9Sstevel@tonic-gate 	 */
21077c478bd9Sstevel@tonic-gate 	if ((lml->lm_flags & (LML_FLG_TRC_VERBOSE | LML_FLG_TRC_SEARCH)) &&
21087c478bd9Sstevel@tonic-gate 	    ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0))
21097c478bd9Sstevel@tonic-gate 		(void) printf(MSG_INTL(MSG_LDD_FIL_FIND), name, NAME(clmp));
21107c478bd9Sstevel@tonic-gate 
211156deab07SRod Evans 	/*
211256deab07SRod Evans 	 * Propagate any knowledge of a slash within the path name.
211356deab07SRod Evans 	 */
211456deab07SRod Evans 	if (pdp->pd_flags & PD_FLG_PNSLASH)
211556deab07SRod Evans 		fdp->fd_flags |= FLG_FD_SLASH;
211656deab07SRod Evans 
21177c478bd9Sstevel@tonic-gate 	/*
21182020b2b6SRod Evans 	 * If we're being audited tell any audit libraries of the file we're
21197c478bd9Sstevel@tonic-gate 	 * about to go search for.
21207c478bd9Sstevel@tonic-gate 	 */
21212020b2b6SRod Evans 	if (aud_activity ||
21222020b2b6SRod Evans 	    ((lml->lm_tflags | AFLAGS(clmp)) & LML_TFLG_AUD_ACTIVITY))
21237c478bd9Sstevel@tonic-gate 		audit_activity(clmp, LA_ACT_ADD);
21247c478bd9Sstevel@tonic-gate 
212556deab07SRod Evans 	if ((lml->lm_tflags | AFLAGS(clmp)) & LML_TFLG_AUD_OBJSEARCH) {
212656deab07SRod Evans 		char	*aname;
21277c478bd9Sstevel@tonic-gate 
21287c478bd9Sstevel@tonic-gate 		/*
21297c478bd9Sstevel@tonic-gate 		 * The auditor can indicate that this object should be ignored.
21307c478bd9Sstevel@tonic-gate 		 */
213156deab07SRod Evans 		if ((aname =
213256deab07SRod Evans 		    audit_objsearch(clmp, name, LA_SER_ORIG)) == NULL) {
21337247f888Srie 			DBG_CALL(Dbg_audit_terminate(lml, name));
213456deab07SRod Evans 			return (NULL);
21357c478bd9Sstevel@tonic-gate 		}
21367c478bd9Sstevel@tonic-gate 
21377247f888Srie 		if (name != aname) {
213856deab07SRod Evans 			fdp->fd_flags &= ~FLG_FD_SLASH;
213956deab07SRod Evans 			name = aname;
21407c478bd9Sstevel@tonic-gate 		}
21417c478bd9Sstevel@tonic-gate 	}
214256deab07SRod Evans 	fdp->fd_oname = name;
214356deab07SRod Evans 	return (name);
21447c478bd9Sstevel@tonic-gate }
21457c478bd9Sstevel@tonic-gate 
21467c478bd9Sstevel@tonic-gate /*
21477c478bd9Sstevel@tonic-gate  * Having loaded an object and created a link-map to describe it, finish
21487c478bd9Sstevel@tonic-gate  * processing this stage, including verifying any versioning requirements,
21497c478bd9Sstevel@tonic-gate  * updating the objects mode, creating a handle if necessary, and adding this
21507c478bd9Sstevel@tonic-gate  * object to existing handles if required.
21517c478bd9Sstevel@tonic-gate  */
2152390b98b5Srie static int
load_finish(Lm_list * lml,const char * name,Rt_map * clmp,int nmode,uint_t flags,Grp_hdl ** hdl,Rt_map * nlmp)2153fb1354edSrie load_finish(Lm_list *lml, const char *name, Rt_map *clmp, int nmode,
2154fb1354edSrie     uint_t flags, Grp_hdl **hdl, Rt_map *nlmp)
21557c478bd9Sstevel@tonic-gate {
21562017c965SRod Evans 	Aliste		idx1;
2157cce0e03bSab 	Grp_hdl		*ghp;
21587c478bd9Sstevel@tonic-gate 	int		promote;
21592017c965SRod Evans 	uint_t		rdflags;
21607c478bd9Sstevel@tonic-gate 
21617c478bd9Sstevel@tonic-gate 	/*
21622017c965SRod Evans 	 * If this dependency is associated with a required version ensure that
21637c478bd9Sstevel@tonic-gate 	 * the version is present in the loaded file.
21647c478bd9Sstevel@tonic-gate 	 */
216556deab07SRod Evans 	if (((rtld_flags & RT_FL_NOVERSION) == 0) && THIS_IS_ELF(clmp) &&
216656deab07SRod Evans 	    VERNEED(clmp) && (elf_verify_vers(name, clmp, nlmp) == 0))
21677c478bd9Sstevel@tonic-gate 		return (0);
21687c478bd9Sstevel@tonic-gate 
21697c478bd9Sstevel@tonic-gate 	/*
21707c478bd9Sstevel@tonic-gate 	 * If this object has indicated that it should be isolated as a group
21717c478bd9Sstevel@tonic-gate 	 * (DT_FLAGS_1 contains DF_1_GROUP - object was built with -B group),
21727c478bd9Sstevel@tonic-gate 	 * or if the callers direct bindings indicate it should be isolated as
21732017c965SRod Evans 	 * a group (DYNINFO flags contains FLG_DI_GROUP - dependency following
21747c478bd9Sstevel@tonic-gate 	 * -zgroupperm), establish the appropriate mode.
21757c478bd9Sstevel@tonic-gate 	 *
21767c478bd9Sstevel@tonic-gate 	 * The intent of an object defining itself as a group is to isolate the
21777c478bd9Sstevel@tonic-gate 	 * relocation of the group within its own members, however, unless
21787c478bd9Sstevel@tonic-gate 	 * opened through dlopen(), in which case we assume dlsym() will be used
21792017c965SRod Evans 	 * to locate symbols in the new object, we still need to associate the
21802017c965SRod Evans 	 * new object with the caller so that the caller can bind to this new
21812017c965SRod Evans 	 * object.  This is equivalent to a dlopen(RTLD_GROUP) and dlsym()
21822017c965SRod Evans 	 * using the returned handle.
21837c478bd9Sstevel@tonic-gate 	 */
21847c478bd9Sstevel@tonic-gate 	if ((FLAGS(nlmp) | flags) & FLG_RT_SETGROUP) {
21857c478bd9Sstevel@tonic-gate 		nmode &= ~RTLD_WORLD;
21867c478bd9Sstevel@tonic-gate 		nmode |= RTLD_GROUP;
21877c478bd9Sstevel@tonic-gate 
21887c478bd9Sstevel@tonic-gate 		/*
21892017c965SRod Evans 		 * If the object wasn't explicitly dlopen()'ed, in which case a
21902017c965SRod Evans 		 * handle would have been requested, associate the object with
21917c478bd9Sstevel@tonic-gate 		 * the parent.
21927c478bd9Sstevel@tonic-gate 		 */
21932017c965SRod Evans 		if ((flags & FLG_RT_PUBHDL) == 0)
21947c478bd9Sstevel@tonic-gate 			nmode |= RTLD_PARENT;
21957c478bd9Sstevel@tonic-gate 	}
21967c478bd9Sstevel@tonic-gate 
21977c478bd9Sstevel@tonic-gate 	/*
21987c478bd9Sstevel@tonic-gate 	 * Establish new mode and flags.
21997c478bd9Sstevel@tonic-gate 	 */
220056deab07SRod Evans 	promote = update_mode(nlmp, MODE(nlmp), nmode);
22017c478bd9Sstevel@tonic-gate 	FLAGS(nlmp) |= flags;
22027c478bd9Sstevel@tonic-gate 
22032017c965SRod Evans 	/*
22042017c965SRod Evans 	 * Establish the flags for any referenced dependency descriptors
22052017c965SRod Evans 	 * (Grp_desc).
22062017c965SRod Evans 	 *
22072017c965SRod Evans 	 *  -	The referenced object is available for dlsym().
22082017c965SRod Evans 	 *  -	The referenced object is available to relocate against.
22092017c965SRod Evans 	 *  -	The referenced object should have it's dependencies
22102017c965SRod Evans 	 *	added to this handle
22112017c965SRod Evans 	 */
22122017c965SRod Evans 	rdflags = (GPD_DLSYM | GPD_RELOC | GPD_ADDEPS);
22132017c965SRod Evans 
22147c478bd9Sstevel@tonic-gate 	/*
22157c478bd9Sstevel@tonic-gate 	 * If we've been asked to establish a handle create one for this object.
22167c478bd9Sstevel@tonic-gate 	 * Or, if this object has already been analyzed, but this reference
22172017c965SRod Evans 	 * requires that the mode of the object be promoted, create a private
22187c478bd9Sstevel@tonic-gate 	 * handle to propagate the new modes to all this objects dependencies.
22197c478bd9Sstevel@tonic-gate 	 */
22202017c965SRod Evans 	if ((FLAGS(nlmp) & (FLG_RT_PUBHDL | FLG_RT_PRIHDL)) ||
22212017c965SRod Evans 	    (promote && (FLAGS(nlmp) & FLG_RT_ANALYZED))) {
22222017c965SRod Evans 		uint_t	oflags, hflags, cdflags = 0;
22237c478bd9Sstevel@tonic-gate 
22248af2c5b9Srie 		/*
22258af2c5b9Srie 		 * Establish any flags for the handle (Grp_hdl).
22268af2c5b9Srie 		 *
22272017c965SRod Evans 		 *  -	Public handles establish dependencies between objects
22282017c965SRod Evans 		 *	that must be taken into account when dlclose()'ing
22292017c965SRod Evans 		 *	objects.  Private handles provide for collecting
22302017c965SRod Evans 		 *	dependencies, but do not affect dlclose().  Note that
22312017c965SRod Evans 		 *	a handle may already exist, but the public/private
22322017c965SRod Evans 		 *	state is set to trigger the required propagation of the
22332017c965SRod Evans 		 *	handle's flags and any dependency gathering.
22342017c965SRod Evans 		 *  -	Use of the RTLD_FIRST flag indicates that only the first
22358af2c5b9Srie 		 *	dependency on the handle (the new object) can be used
22368af2c5b9Srie 		 *	to satisfy dlsym() requests.
22378af2c5b9Srie 		 */
22382017c965SRod Evans 		if (FLAGS(nlmp) & FLG_RT_PUBHDL)
22392017c965SRod Evans 			hflags = GPH_PUBLIC;
22402017c965SRod Evans 		else
22412017c965SRod Evans 			hflags = GPH_PRIVATE;
22422017c965SRod Evans 
22437c478bd9Sstevel@tonic-gate 		if (nmode & RTLD_FIRST)
22442017c965SRod Evans 			hflags |= GPH_FIRST;
22458af2c5b9Srie 
22468af2c5b9Srie 		/*
22478af2c5b9Srie 		 * Establish the flags for this callers dependency descriptor
22488af2c5b9Srie 		 * (Grp_desc).
22498af2c5b9Srie 		 *
22502017c965SRod Evans 		 *  -	The creation of a public handle creates a descriptor
22512017c965SRod Evans 		 *	for the referenced object and the caller (parent).
22528af2c5b9Srie 		 *	Typically, the handle is created for dlopen() or for
22532017c965SRod Evans 		 *	filtering.  A private handle does not need to maintain
22542017c965SRod Evans 		 *	a descriptor to the parent.
22552017c965SRod Evans 		 *  -	Use of the RTLD_PARENT flag indicates that the parent
22568af2c5b9Srie 		 *	can be relocated against.
22578af2c5b9Srie 		 */
22582017c965SRod Evans 		if (FLAGS(nlmp) & FLG_RT_PUBHDL) {
22592017c965SRod Evans 			cdflags |= GPD_PARENT;
22602017c965SRod Evans 			if (nmode & RTLD_PARENT)
22612017c965SRod Evans 				cdflags |= GPD_RELOC;
22622017c965SRod Evans 		}
22637c478bd9Sstevel@tonic-gate 
22647c478bd9Sstevel@tonic-gate 		/*
22652017c965SRod Evans 		 * Now that the handle flags have been established, remove any
22662017c965SRod Evans 		 * handle definition from the referenced object so that the
22672017c965SRod Evans 		 * definitions don't mistakenly get inherited by a dependency.
22687c478bd9Sstevel@tonic-gate 		 */
22697c478bd9Sstevel@tonic-gate 		oflags = FLAGS(nlmp);
22702017c965SRod Evans 		FLAGS(nlmp) &= ~(FLG_RT_PUBHDL | FLG_RT_PRIHDL);
22717c478bd9Sstevel@tonic-gate 
22728af2c5b9Srie 		DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD));
22732017c965SRod Evans 		if ((ghp = hdl_create(lml, nlmp, clmp, hflags, rdflags,
22742017c965SRod Evans 		    cdflags)) == NULL)
22757c478bd9Sstevel@tonic-gate 			return (0);
22767c478bd9Sstevel@tonic-gate 
22777c478bd9Sstevel@tonic-gate 		/*
22787c478bd9Sstevel@tonic-gate 		 * Add any dependencies that are already loaded, to the handle.
22797c478bd9Sstevel@tonic-gate 		 */
228002ca3e02Srie 		if (hdl_initialize(ghp, nlmp, nmode, promote) == 0)
22817c478bd9Sstevel@tonic-gate 			return (0);
22827c478bd9Sstevel@tonic-gate 
22837c478bd9Sstevel@tonic-gate 		if (hdl)
22847c478bd9Sstevel@tonic-gate 			*hdl = ghp;
22857c478bd9Sstevel@tonic-gate 
22867c478bd9Sstevel@tonic-gate 		/*
22872017c965SRod Evans 		 * If we were asked to create a public handle, we're done.
22888af2c5b9Srie 		 *
22892017c965SRod Evans 		 * If this is a private handle request, then the handle is left
22902017c965SRod Evans 		 * intact with a GPH_PRIVATE identifier.  This handle is a
22912017c965SRod Evans 		 * convenience for processing the dependencies of this object,
22922017c965SRod Evans 		 * but does not affect how this object might be dlclose()'d.
22932017c965SRod Evans 		 * For a private handle, fall through to carry out any group
22942017c965SRod Evans 		 * processing.
22952017c965SRod Evans 		 */
22962017c965SRod Evans 		if (oflags & FLG_RT_PUBHDL)
22972017c965SRod Evans 			return (1);
22987c478bd9Sstevel@tonic-gate 	}
22997c478bd9Sstevel@tonic-gate 
23007c478bd9Sstevel@tonic-gate 	/*
23017c478bd9Sstevel@tonic-gate 	 * If the caller isn't part of a group we're done.
23027c478bd9Sstevel@tonic-gate 	 */
2303cce0e03bSab 	if (GROUPS(clmp) == NULL)
23047c478bd9Sstevel@tonic-gate 		return (1);
23057c478bd9Sstevel@tonic-gate 
23067c478bd9Sstevel@tonic-gate 	/*
23077c478bd9Sstevel@tonic-gate 	 * Determine if our caller is already associated with a handle, if so
23087c478bd9Sstevel@tonic-gate 	 * we need to add this object to any handles that already exist.
23097c478bd9Sstevel@tonic-gate 	 * Traverse the list of groups our caller is a member of and add this
23107c478bd9Sstevel@tonic-gate 	 * new link-map to those groups.
23117c478bd9Sstevel@tonic-gate 	 */
23122017c965SRod Evans 	for (APLIST_TRAVERSE(GROUPS(clmp), idx1, ghp)) {
23132017c965SRod Evans 		Aliste		idx2;
23147c478bd9Sstevel@tonic-gate 		Grp_desc	*gdp;
23152017c965SRod Evans 		int		ale;
2316cce0e03bSab 		Rt_map		*dlmp1;
2317cce0e03bSab 		APlist		*lmalp = NULL;
23187c478bd9Sstevel@tonic-gate 
23192017c965SRod Evans 		DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD));
23202017c965SRod Evans 
23217c478bd9Sstevel@tonic-gate 		/*
23227c478bd9Sstevel@tonic-gate 		 * If the caller doesn't indicate that its dependencies should
23237c478bd9Sstevel@tonic-gate 		 * be added to a handle, ignore it.  This case identifies a
23247c478bd9Sstevel@tonic-gate 		 * parent of a dlopen(RTLD_PARENT) request.
23257c478bd9Sstevel@tonic-gate 		 */
23262017c965SRod Evans 		for (ALIST_TRAVERSE(ghp->gh_depends, idx2, gdp)) {
23277c478bd9Sstevel@tonic-gate 			if (gdp->gd_depend == clmp)
23287c478bd9Sstevel@tonic-gate 				break;
23297c478bd9Sstevel@tonic-gate 		}
23307c478bd9Sstevel@tonic-gate 		if ((gdp->gd_flags & GPD_ADDEPS) == 0)
23317c478bd9Sstevel@tonic-gate 			continue;
23327c478bd9Sstevel@tonic-gate 
23332017c965SRod Evans 		if ((gdp = hdl_add(ghp, nlmp, rdflags, &ale)) == NULL)
23347c478bd9Sstevel@tonic-gate 			return (0);
23357c478bd9Sstevel@tonic-gate 
23367c478bd9Sstevel@tonic-gate 		/*
23377c478bd9Sstevel@tonic-gate 		 * If this member already exists then its dependencies will
23387c478bd9Sstevel@tonic-gate 		 * have already been processed.
23397c478bd9Sstevel@tonic-gate 		 */
23402017c965SRod Evans 		if (ale == ALE_EXISTS)
23417c478bd9Sstevel@tonic-gate 			continue;
23427c478bd9Sstevel@tonic-gate 
23437c478bd9Sstevel@tonic-gate 		/*
23447c478bd9Sstevel@tonic-gate 		 * If the object we've added has just been opened, it will not
23457c478bd9Sstevel@tonic-gate 		 * yet have been processed for its dependencies, these will be
23467c478bd9Sstevel@tonic-gate 		 * added on later calls to load_one().  If it doesn't have any
23477c478bd9Sstevel@tonic-gate 		 * dependencies we're also done.
23487c478bd9Sstevel@tonic-gate 		 */
23497c478bd9Sstevel@tonic-gate 		if (((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0) ||
2350cce0e03bSab 		    (DEPENDS(nlmp) == NULL))
23517c478bd9Sstevel@tonic-gate 			continue;
23527c478bd9Sstevel@tonic-gate 
23537c478bd9Sstevel@tonic-gate 		/*
23547c478bd9Sstevel@tonic-gate 		 * Otherwise, this object exists and has dependencies, so add
23557c478bd9Sstevel@tonic-gate 		 * all of its dependencies to the handle were operating on.
23567c478bd9Sstevel@tonic-gate 		 */
235756deab07SRod Evans 		if (aplist_append(&lmalp, nlmp, AL_CNT_DEPCLCT) == NULL)
23587c478bd9Sstevel@tonic-gate 			return (0);
23597c478bd9Sstevel@tonic-gate 
23602017c965SRod Evans 		for (APLIST_TRAVERSE(lmalp, idx2, dlmp1)) {
23612017c965SRod Evans 			Aliste		idx3;
236267d74cc3SToomas Soome 			Bnd_desc	*bdp;
23637c478bd9Sstevel@tonic-gate 
23647c478bd9Sstevel@tonic-gate 			/*
23657c478bd9Sstevel@tonic-gate 			 * Add any dependencies of this dependency to the
23667c478bd9Sstevel@tonic-gate 			 * dynamic dependency list so they can be further
23677c478bd9Sstevel@tonic-gate 			 * processed.
23687c478bd9Sstevel@tonic-gate 			 */
23692017c965SRod Evans 			for (APLIST_TRAVERSE(DEPENDS(dlmp1), idx3, bdp)) {
2370aa736cbeSrie 				Rt_map	*dlmp2 = bdp->b_depend;
23717c478bd9Sstevel@tonic-gate 
23727c478bd9Sstevel@tonic-gate 				if ((bdp->b_flags & BND_NEEDED) == 0)
23737c478bd9Sstevel@tonic-gate 					continue;
23747c478bd9Sstevel@tonic-gate 
2375cce0e03bSab 				if (aplist_test(&lmalp, dlmp2,
23767c478bd9Sstevel@tonic-gate 				    AL_CNT_DEPCLCT) == 0) {
23777c478bd9Sstevel@tonic-gate 					free(lmalp);
23787c478bd9Sstevel@tonic-gate 					return (0);
23797c478bd9Sstevel@tonic-gate 				}
23807c478bd9Sstevel@tonic-gate 			}
23817c478bd9Sstevel@tonic-gate 
23827c478bd9Sstevel@tonic-gate 			if (nlmp == dlmp1)
23837c478bd9Sstevel@tonic-gate 				continue;
23847c478bd9Sstevel@tonic-gate 
23852017c965SRod Evans 			if ((gdp =
23862017c965SRod Evans 			    hdl_add(ghp, dlmp1, rdflags, &ale)) == NULL) {
238756deab07SRod Evans 				free(lmalp);
238856deab07SRod Evans 				return (0);
23897c478bd9Sstevel@tonic-gate 			}
239056deab07SRod Evans 
2391e0e63816SRod Evans 			if (ale == ALE_CREATE)
2392e0e63816SRod Evans 				(void) update_mode(dlmp1, MODE(dlmp1), nmode);
23937c478bd9Sstevel@tonic-gate 		}
23947c478bd9Sstevel@tonic-gate 		free(lmalp);
23957c478bd9Sstevel@tonic-gate 	}
23967c478bd9Sstevel@tonic-gate 	return (1);
23977c478bd9Sstevel@tonic-gate }
23987c478bd9Sstevel@tonic-gate 
23997c478bd9Sstevel@tonic-gate /*
24007c478bd9Sstevel@tonic-gate  * The central routine for loading shared objects.  Insures ldd() diagnostics,
24012020b2b6SRod Evans  * handle creation, and any other related additions are all done in one place.
24027c478bd9Sstevel@tonic-gate  */
240356deab07SRod Evans Rt_map *
load_path(Lm_list * lml,Aliste lmco,Rt_map * clmp,int nmode,uint_t flags,Grp_hdl ** hdl,Fdesc * fdp,Rej_desc * rej,int * in_nfavl)240456deab07SRod Evans load_path(Lm_list *lml, Aliste lmco, Rt_map *clmp, int nmode, uint_t flags,
240556deab07SRod Evans     Grp_hdl **hdl, Fdesc *fdp, Rej_desc *rej, int *in_nfavl)
24067c478bd9Sstevel@tonic-gate {
240756deab07SRod Evans 	const char	*name = fdp->fd_oname;
24087247f888Srie 	Rt_map		*nlmp;
24097c478bd9Sstevel@tonic-gate 
24107c478bd9Sstevel@tonic-gate 	if ((nmode & RTLD_NOLOAD) == 0) {
2411e0e63816SRod Evans 		int	oin_nfavl;
2412e0e63816SRod Evans 
2413e0e63816SRod Evans 		/*
2414e0e63816SRod Evans 		 * Keep track of the number of not-found loads.
2415e0e63816SRod Evans 		 */
2416e0e63816SRod Evans 		if (in_nfavl)
2417e0e63816SRod Evans 			oin_nfavl = *in_nfavl;
2418e0e63816SRod Evans 
24197c478bd9Sstevel@tonic-gate 		/*
24207c478bd9Sstevel@tonic-gate 		 * If this isn't a noload request attempt to load the file.
24217c478bd9Sstevel@tonic-gate 		 */
242256deab07SRod Evans 		if ((nlmp = load_so(lml, lmco, clmp, flags, fdp, rej,
242356deab07SRod Evans 		    in_nfavl)) == NULL)
242437ffaf83SRod Evans 			return (NULL);
24257c478bd9Sstevel@tonic-gate 
2426e0e63816SRod Evans 		/*
2427e0e63816SRod Evans 		 * If this file has been found, reset the not-found load count.
2428e0e63816SRod Evans 		 * Although a search for this file might have inspected a number
2429e0e63816SRod Evans 		 * of non-existent path names, the file has been found so there
243008278a5eSRod Evans 		 * is no need to accumulate a non-found count, as this may
2431e0e63816SRod Evans 		 * trigger unnecessary fall back (retry) processing.
2432e0e63816SRod Evans 		 */
2433e0e63816SRod Evans 		if (in_nfavl)
2434e0e63816SRod Evans 			*in_nfavl = oin_nfavl;
2435e0e63816SRod Evans 
24367c478bd9Sstevel@tonic-gate 		/*
24377c478bd9Sstevel@tonic-gate 		 * If we've loaded a library which identifies itself as not
24387c478bd9Sstevel@tonic-gate 		 * being dlopen()'able catch it here.  Let non-dlopen()'able
24397c478bd9Sstevel@tonic-gate 		 * objects through under RTLD_CONFGEN as they're only being
24407c478bd9Sstevel@tonic-gate 		 * mapped to be dldump()'ed.
24417c478bd9Sstevel@tonic-gate 		 */
24427c478bd9Sstevel@tonic-gate 		if ((rtld_flags & RT_FL_APPLIC) && ((FLAGS(nlmp) &
24437c478bd9Sstevel@tonic-gate 		    (FLG_RT_NOOPEN | FLG_RT_RELOCED)) == FLG_RT_NOOPEN) &&
24447c478bd9Sstevel@tonic-gate 		    ((nmode & RTLD_CONFGEN) == 0)) {
24457c478bd9Sstevel@tonic-gate 			Rej_desc	_rej = { 0 };
24467c478bd9Sstevel@tonic-gate 
24477c478bd9Sstevel@tonic-gate 			_rej.rej_name = name;
24487c478bd9Sstevel@tonic-gate 			_rej.rej_type = SGS_REJ_STR;
24497c478bd9Sstevel@tonic-gate 			_rej.rej_str = MSG_INTL(MSG_GEN_NOOPEN);
2450ba2be530Sab 			DBG_CALL(Dbg_file_rejected(lml, &_rej, M_MACH));
245131fdd7caSab 			rejection_inherit(rej, &_rej);
24522020b2b6SRod Evans 			remove_so(lml, nlmp, clmp);
245337ffaf83SRod Evans 			return (NULL);
24547c478bd9Sstevel@tonic-gate 		}
24557c478bd9Sstevel@tonic-gate 	} else {
24567c478bd9Sstevel@tonic-gate 		/*
24577c478bd9Sstevel@tonic-gate 		 * If it's a NOLOAD request - check to see if the object
24587c478bd9Sstevel@tonic-gate 		 * has already been loaded.
24597c478bd9Sstevel@tonic-gate 		 */
2460*80422cafSToomas Soome 		nlmp = is_so_loaded(lml, name, in_nfavl);
2461*80422cafSToomas Soome 		if (nlmp != NULL) {
24627c478bd9Sstevel@tonic-gate 			if ((lml->lm_flags & LML_FLG_TRC_VERBOSE) &&
24637c478bd9Sstevel@tonic-gate 			    ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) {
24647c478bd9Sstevel@tonic-gate 				(void) printf(MSG_INTL(MSG_LDD_FIL_FIND), name,
24657247f888Srie 				    NAME(clmp));
24667247f888Srie 				/* BEGIN CSTYLED */
24677c478bd9Sstevel@tonic-gate 				if (*name == '/')
24687c478bd9Sstevel@tonic-gate 				    (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH),
24697c478bd9Sstevel@tonic-gate 					name, MSG_ORIG(MSG_STR_EMPTY),
24707c478bd9Sstevel@tonic-gate 					MSG_ORIG(MSG_STR_EMPTY));
24717c478bd9Sstevel@tonic-gate 				else
24727c478bd9Sstevel@tonic-gate 				    (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV),
24737c478bd9Sstevel@tonic-gate 					name, NAME(nlmp),
24747c478bd9Sstevel@tonic-gate 					MSG_ORIG(MSG_STR_EMPTY),
24757c478bd9Sstevel@tonic-gate 					MSG_ORIG(MSG_STR_EMPTY));
24767247f888Srie 				/* END CSTYLED */
24777c478bd9Sstevel@tonic-gate 			}
24787c478bd9Sstevel@tonic-gate 		} else {
24797c478bd9Sstevel@tonic-gate 			Rej_desc	_rej = { 0 };
24807c478bd9Sstevel@tonic-gate 
24817c478bd9Sstevel@tonic-gate 			_rej.rej_name = name;
24827c478bd9Sstevel@tonic-gate 			_rej.rej_type = SGS_REJ_STR;
24837c478bd9Sstevel@tonic-gate 			_rej.rej_str = strerror(ENOENT);
2484ba2be530Sab 			DBG_CALL(Dbg_file_rejected(lml, &_rej, M_MACH));
248531fdd7caSab 			rejection_inherit(rej, &_rej);
248637ffaf83SRod Evans 			return (NULL);
24877c478bd9Sstevel@tonic-gate 		}
24887c478bd9Sstevel@tonic-gate 	}
24897c478bd9Sstevel@tonic-gate 
24907c478bd9Sstevel@tonic-gate 	/*
24917c478bd9Sstevel@tonic-gate 	 * Finish processing this loaded object.
24927c478bd9Sstevel@tonic-gate 	 */
2493390b98b5Srie 	if (load_finish(lml, name, clmp, nmode, flags, hdl, nlmp) == 0) {
2494390b98b5Srie 		FLAGS(nlmp) &= ~FLG_RT_NEWLOAD;
2495390b98b5Srie 
2496390b98b5Srie 		/*
2497390b98b5Srie 		 * If this object has already been analyzed, then it is in use,
2498390b98b5Srie 		 * so even though this operation has failed, it should not be
2499390b98b5Srie 		 * torn down.
2500390b98b5Srie 		 */
2501390b98b5Srie 		if ((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0)
25022020b2b6SRod Evans 			remove_so(lml, nlmp, clmp);
250337ffaf83SRod Evans 		return (NULL);
2504390b98b5Srie 	}
25057c478bd9Sstevel@tonic-gate 
25067c478bd9Sstevel@tonic-gate 	/*
2507390b98b5Srie 	 * If this object is new, and we're being audited, tell the audit
25082020b2b6SRod Evans 	 * libraries of the file we've just opened.  Note, if the new link-map
2509390b98b5Srie 	 * requires local auditing of its dependencies we also register its
2510390b98b5Srie 	 * opening.
25117c478bd9Sstevel@tonic-gate 	 */
2512390b98b5Srie 	if (FLAGS(nlmp) & FLG_RT_NEWLOAD) {
2513390b98b5Srie 		FLAGS(nlmp) &= ~FLG_RT_NEWLOAD;
2514390b98b5Srie 
25152020b2b6SRod Evans 		if ((lml->lm_tflags | AFLAGS(clmp) | AFLAGS(nlmp)) &
25162020b2b6SRod Evans 		    LML_TFLG_AUD_MASK) {
2517390b98b5Srie 			if (audit_objopen(clmp, nlmp) == 0) {
25182020b2b6SRod Evans 				remove_so(lml, nlmp, clmp);
251937ffaf83SRod Evans 				return (NULL);
2520390b98b5Srie 			}
2521390b98b5Srie 		}
2522390b98b5Srie 	}
2523390b98b5Srie 	return (nlmp);
25247c478bd9Sstevel@tonic-gate }
25257c478bd9Sstevel@tonic-gate 
25267c478bd9Sstevel@tonic-gate /*
25277c478bd9Sstevel@tonic-gate  * Load one object from a possible list of objects.  Typically, for requests
25287c478bd9Sstevel@tonic-gate  * such as NEEDED's, only one object is specified.  However, this object could
252908278a5eSRod Evans  * be specified using $ISALIST or $CAPABILITY, in which case only the first
253008278a5eSRod Evans  * object that can be loaded is used (ie. the best).
25317c478bd9Sstevel@tonic-gate  */
25327c478bd9Sstevel@tonic-gate Rt_map *
load_one(Lm_list * lml,Aliste lmco,Alist * palp,Rt_map * clmp,int mode,uint_t flags,Grp_hdl ** hdl,int * in_nfavl)253356deab07SRod Evans load_one(Lm_list *lml, Aliste lmco, Alist *palp, Rt_map *clmp, int mode,
25349aa23310Srie     uint_t flags, Grp_hdl **hdl, int *in_nfavl)
25357c478bd9Sstevel@tonic-gate {
25367c478bd9Sstevel@tonic-gate 	Rej_desc	rej = { 0 };
253756deab07SRod Evans 	Aliste		idx;
253867d74cc3SToomas Soome 	Pdesc		*pdp;
25397c478bd9Sstevel@tonic-gate 	const char	*name;
25407c478bd9Sstevel@tonic-gate 
254156deab07SRod Evans 	for (ALIST_TRAVERSE(palp, idx, pdp)) {
254256deab07SRod Evans 		Rt_map	*lmp = NULL;
25437247f888Srie 
25447c478bd9Sstevel@tonic-gate 		/*
254508278a5eSRod Evans 		 * A $CAPABILITY/$HWCAP requirement can expand into a number of
254608278a5eSRod Evans 		 * candidates.
25477c478bd9Sstevel@tonic-gate 		 */
254808278a5eSRod Evans 		if (pdp->pd_flags & PD_TKN_CAP) {
254908278a5eSRod Evans 			lmp = load_cap(lml, lmco, pdp->pd_pname, clmp,
255008278a5eSRod Evans 			    mode, (flags | FLG_RT_CAP), hdl, &rej, in_nfavl);
25517c478bd9Sstevel@tonic-gate 		} else {
255256deab07SRod Evans 			Fdesc	fd = { 0 };
255356deab07SRod Evans 
255456deab07SRod Evans 			/*
255556deab07SRod Evans 			 * Trace the inspection of this file, determine any
255656deab07SRod Evans 			 * auditor substitution, and seed the file descriptor
255756deab07SRod Evans 			 * with the originating name.
255856deab07SRod Evans 			 */
255956deab07SRod Evans 			if (load_trace(lml, pdp, clmp, &fd) == NULL)
256056deab07SRod Evans 				continue;
256156deab07SRod Evans 
256256deab07SRod Evans 			/*
256356deab07SRod Evans 			 * Locate and load the file.
256456deab07SRod Evans 			 */
256556deab07SRod Evans 			lmp = load_path(lml, lmco, clmp, mode, flags, hdl, &fd,
256656deab07SRod Evans 			    &rej, in_nfavl);
25677c478bd9Sstevel@tonic-gate 		}
256856deab07SRod Evans 		if (lmp)
256956deab07SRod Evans 			return (lmp);
25707c478bd9Sstevel@tonic-gate 	}
25717c478bd9Sstevel@tonic-gate 
25727c478bd9Sstevel@tonic-gate 	/*
257356deab07SRod Evans 	 * If no objects can be found, use the first path name from the Alist
257456deab07SRod Evans 	 * to provide a diagnostic.  If this pathname originated from an
257556deab07SRod Evans 	 * expanded token, use the original name for any diagnostic output.
25767c478bd9Sstevel@tonic-gate 	 */
257756deab07SRod Evans 	pdp = alist_item(palp, 0);
257856deab07SRod Evans 
257956deab07SRod Evans 	if ((name = pdp->pd_oname) == 0)
258056deab07SRod Evans 		name = pdp->pd_pname;
25817c478bd9Sstevel@tonic-gate 
25827c478bd9Sstevel@tonic-gate 	file_notfound(lml, name, clmp, flags, &rej);
258337ffaf83SRod Evans 	return (NULL);
25847c478bd9Sstevel@tonic-gate }
25857c478bd9Sstevel@tonic-gate 
25869a411307Srie /*
25879a411307Srie  * Determine whether a symbol is defined as an interposer.
25889a411307Srie  */
25899a411307Srie int
is_sym_interposer(Rt_map * lmp,Sym * sym)25909a411307Srie is_sym_interposer(Rt_map *lmp, Sym *sym)
25919a411307Srie {
25929a411307Srie 	Syminfo	*sip = SYMINFO(lmp);
25939a411307Srie 
25949a411307Srie 	if (sip) {
25959a411307Srie 		ulong_t	ndx;
25969a411307Srie 
25979a411307Srie 		ndx = (((ulong_t)sym - (ulong_t)SYMTAB(lmp)) / SYMENT(lmp));
25989a411307Srie 		/* LINTED */
25999a411307Srie 		sip = (Syminfo *)((char *)sip + (ndx * SYMINENT(lmp)));
26009a411307Srie 		if (sip->si_flags & SYMINFO_FLG_INTERPOSE)
26019a411307Srie 			return (1);
26029a411307Srie 	}
26039a411307Srie 	return (0);
26049a411307Srie }
26059a411307Srie 
26067c478bd9Sstevel@tonic-gate /*
26077c478bd9Sstevel@tonic-gate  * While processing direct or group bindings, determine whether the object to
26087c478bd9Sstevel@tonic-gate  * which we've bound can be interposed upon.  In this context, copy relocations
26097c478bd9Sstevel@tonic-gate  * are a form of interposition.
26107c478bd9Sstevel@tonic-gate  */
261108278a5eSRod Evans static int
lookup_sym_interpose(Slookup * slp,Sresult * srp,uint_t * binfo,int * in_nfavl)261208278a5eSRod Evans lookup_sym_interpose(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl)
26137c478bd9Sstevel@tonic-gate {
261408278a5eSRod Evans 	Rt_map		*lmp, *clmp, *dlmp = srp->sr_dmap;
261508278a5eSRod Evans 	Sym		*osym = srp->sr_sym;
26167c478bd9Sstevel@tonic-gate 	Slookup		sl;
2617adbfe822Srie 	Lm_list		*lml;
26187c478bd9Sstevel@tonic-gate 
26197c478bd9Sstevel@tonic-gate 	/*
26207c478bd9Sstevel@tonic-gate 	 * If we've bound to a copy relocation definition then we need to assign
26217c478bd9Sstevel@tonic-gate 	 * this binding to the original copy reference.  Fabricate an inter-
26227c478bd9Sstevel@tonic-gate 	 * position diagnostic, as this is a legitimate form of interposition.
26237c478bd9Sstevel@tonic-gate 	 */
262408278a5eSRod Evans 	if (osym && (FLAGS1(dlmp) & FL1_RT_COPYTOOK)) {
26257c478bd9Sstevel@tonic-gate 		Rel_copy	*rcp;
2626cce0e03bSab 		Aliste		idx;
26277c478bd9Sstevel@tonic-gate 
262808278a5eSRod Evans 		for (ALIST_TRAVERSE(COPY_R(dlmp), idx, rcp)) {
2629aa736cbeSrie 			if ((osym == rcp->r_dsym) || (osym->st_value &&
2630aa736cbeSrie 			    (osym->st_value == rcp->r_dsym->st_value))) {
263108278a5eSRod Evans 				srp->sr_dmap = rcp->r_rlmp;
263208278a5eSRod Evans 				srp->sr_sym = rcp->r_rsym;
26337c478bd9Sstevel@tonic-gate 				*binfo |=
26347c478bd9Sstevel@tonic-gate 				    (DBG_BINFO_INTERPOSE | DBG_BINFO_COPYREF);
263508278a5eSRod Evans 				return (1);
26367c478bd9Sstevel@tonic-gate 			}
26377c478bd9Sstevel@tonic-gate 		}
26387c478bd9Sstevel@tonic-gate 	}
26397c478bd9Sstevel@tonic-gate 
2640adbfe822Srie 	/*
2641adbfe822Srie 	 * If a symbol binding has been established, inspect the link-map list
2642adbfe822Srie 	 * of the destination object, otherwise use the link-map list of the
2643adbfe822Srie 	 * original caller.
2644adbfe822Srie 	 */
2645adbfe822Srie 	if (osym)
264608278a5eSRod Evans 		clmp = dlmp;
2647adbfe822Srie 	else
2648adbfe822Srie 		clmp = slp->sl_cmap;
2649adbfe822Srie 
2650adbfe822Srie 	lml = LIST(clmp);
2651adbfe822Srie 	lmp = lml->lm_head;
2652adbfe822Srie 
2653aa736cbeSrie 	/*
2654aa736cbeSrie 	 * Prior to Solaris 8, external references from an executable that were
2655aa736cbeSrie 	 * bound to an uninitialized variable (.bss) within a shared object did
2656aa736cbeSrie 	 * not establish a copy relocation.  This was thought to be an
2657aa736cbeSrie 	 * optimization, to prevent copying zero's to zero's.  Typically,
2658aa736cbeSrie 	 * interposition took its course, with the shared object binding to the
2659aa736cbeSrie 	 * executables data definition.
2660aa736cbeSrie 	 *
2661aa736cbeSrie 	 * This scenario can be broken when this old executable runs against a
2662aa736cbeSrie 	 * new shared object that is directly bound.  With no copy-relocation
2663aa736cbeSrie 	 * record, ld.so.1 has no data to trigger the normal vectoring of the
2664aa736cbeSrie 	 * binding to the executable.
2665aa736cbeSrie 	 *
2666aa736cbeSrie 	 * Starting with Solaris 8, a DT_FLAGS entry is written to all objects,
2667aa736cbeSrie 	 * regardless of there being any DF_ flags entries.  Therefore, an
2668aa736cbeSrie 	 * object without this dynamic tag is susceptible to the copy relocation
2669aa736cbeSrie 	 * issue.  If the executable has no DT_FLAGS tag, and contains the same
2670aa736cbeSrie 	 * .bss symbol definition as has been directly bound to, redirect the
2671aa736cbeSrie 	 * binding to the executables data definition.
2672aa736cbeSrie 	 */
267356deab07SRod Evans 	if (osym && ((FLAGS1(lmp) & FL1_RT_DTFLAGS) == 0) &&
2674adbfe822Srie 	    (FCT(lmp) == &elf_fct) &&
2675466e2a62Srie 	    (ELF_ST_TYPE(osym->st_info) != STT_FUNC) &&
267608278a5eSRod Evans 	    are_bits_zero(dlmp, osym, 0)) {
267708278a5eSRod Evans 		Sresult	sr;
2678aa736cbeSrie 
267908278a5eSRod Evans 		/*
268008278a5eSRod Evans 		 * Initialize a local symbol result descriptor, using the
268108278a5eSRod Evans 		 * original symbol name.  Initialize a local symbol lookup
268208278a5eSRod Evans 		 * descriptor, using the original lookup information, and a
268308278a5eSRod Evans 		 * new initial link-map.
268408278a5eSRod Evans 		 */
268508278a5eSRod Evans 		SRESULT_INIT(sr, slp->sl_name);
2686adbfe822Srie 		sl = *slp;
2687adbfe822Srie 		sl.sl_imap = lmp;
2688adbfe822Srie 
2689aa736cbeSrie 		/*
2690aa736cbeSrie 		 * Determine whether the same symbol name exists within the
2691aa736cbeSrie 		 * executable, that the size and type of symbol are the same,
2692aa736cbeSrie 		 * and that the symbol is also associated with .bss.
2693aa736cbeSrie 		 */
269408278a5eSRod Evans 		if (SYMINTP(lmp)(&sl, &sr, binfo, in_nfavl)) {
269508278a5eSRod Evans 			Sym	*isym = sr.sr_sym;
269608278a5eSRod Evans 
269708278a5eSRod Evans 			if ((isym->st_size == osym->st_size) &&
269808278a5eSRod Evans 			    (isym->st_info == osym->st_info) &&
269908278a5eSRod Evans 			    are_bits_zero(lmp, isym, 1)) {
270008278a5eSRod Evans 				*srp = sr;
270108278a5eSRod Evans 				*binfo |=
270208278a5eSRod Evans 				    (DBG_BINFO_INTERPOSE | DBG_BINFO_COPYREF);
270308278a5eSRod Evans 				return (1);
270408278a5eSRod Evans 			}
2705aa736cbeSrie 		}
2706aa736cbeSrie 	}
2707aa736cbeSrie 
27087c478bd9Sstevel@tonic-gate 	if ((lml->lm_flags & LML_FLG_INTRPOSE) == 0)
270967d74cc3SToomas Soome 		return (0);
27107c478bd9Sstevel@tonic-gate 
27117c478bd9Sstevel@tonic-gate 	/*
27127c478bd9Sstevel@tonic-gate 	 * Traverse the list of known interposers to determine whether any
27137c478bd9Sstevel@tonic-gate 	 * offer the same symbol.  Note, the head of the link-map could be
2714aa736cbeSrie 	 * identified as an interposer.  Otherwise, skip the head of the
2715aa736cbeSrie 	 * link-map, so that we don't bind to any .plt references, or
2716aa736cbeSrie 	 * copy-relocation destinations unintentionally.
27177c478bd9Sstevel@tonic-gate 	 */
27187c478bd9Sstevel@tonic-gate 	lmp = lml->lm_head;
27197c478bd9Sstevel@tonic-gate 	sl = *slp;
2720adbfe822Srie 
27219a411307Srie 	if (((FLAGS(lmp) & MSK_RT_INTPOSE) == 0) || (sl.sl_flags & LKUP_COPY))
2722cb511613SAli Bahrami 		lmp = NEXT_RT_MAP(lmp);
27237c478bd9Sstevel@tonic-gate 
2724cb511613SAli Bahrami 	for (; lmp; lmp = NEXT_RT_MAP(lmp)) {
27257c478bd9Sstevel@tonic-gate 		if (FLAGS(lmp) & FLG_RT_DELETE)
27267c478bd9Sstevel@tonic-gate 			continue;
27279a411307Srie 		if ((FLAGS(lmp) & MSK_RT_INTPOSE) == 0)
27287c478bd9Sstevel@tonic-gate 			break;
27297c478bd9Sstevel@tonic-gate 
2730e0e63816SRod Evans 		/*
2731e0e63816SRod Evans 		 * If we had already bound to this object, there's no point in
2732e0e63816SRod Evans 		 * searching it again, we're done.
2733e0e63816SRod Evans 		 */
273408278a5eSRod Evans 		if (lmp == dlmp)
2735e0e63816SRod Evans 			break;
2736e0e63816SRod Evans 
2737e0e63816SRod Evans 		/*
2738e0e63816SRod Evans 		 * If this interposer can be inspected by the caller, look for
2739e0e63816SRod Evans 		 * the symbol within the interposer.
2740e0e63816SRod Evans 		 */
2741e0e63816SRod Evans 		if (callable(clmp, lmp, 0, sl.sl_flags)) {
274208278a5eSRod Evans 			Sresult		sr;
27439a411307Srie 
274408278a5eSRod Evans 			/*
274508278a5eSRod Evans 			 * Initialize a local symbol result descriptor, using
274608278a5eSRod Evans 			 * the original symbol name.  Initialize a local symbol
274708278a5eSRod Evans 			 * lookup descriptor, using the original lookup
274808278a5eSRod Evans 			 * information, and a new initial link-map.
274908278a5eSRod Evans 			 */
275008278a5eSRod Evans 			SRESULT_INIT(sr, slp->sl_name);
27517c478bd9Sstevel@tonic-gate 			sl.sl_imap = lmp;
275208278a5eSRod Evans 
275308278a5eSRod Evans 			if (SYMINTP(lmp)(&sl, &sr, binfo, in_nfavl)) {
275408278a5eSRod Evans 				Sym	*isym = sr.sr_sym;
275508278a5eSRod Evans 				Rt_map	*ilmp = sr.sr_dmap;
275608278a5eSRod Evans 
27579a411307Srie 				/*
27589a411307Srie 				 * If this object provides individual symbol
27599a411307Srie 				 * interposers, make sure that the symbol we
27609a411307Srie 				 * have found is tagged as an interposer.
27619a411307Srie 				 */
27629a411307Srie 				if ((FLAGS(ilmp) & FLG_RT_SYMINTPO) &&
2763aa736cbeSrie 				    (is_sym_interposer(ilmp, isym) == 0))
27649a411307Srie 					continue;
27659a411307Srie 
27669a411307Srie 				/*
27679a411307Srie 				 * Indicate this binding has occurred to an
27689a411307Srie 				 * interposer, and return the symbol.
27699a411307Srie 				 */
277008278a5eSRod Evans 				*srp = sr;
27717c478bd9Sstevel@tonic-gate 				*binfo |= DBG_BINFO_INTERPOSE;
277208278a5eSRod Evans 				return (1);
27737c478bd9Sstevel@tonic-gate 			}
27747c478bd9Sstevel@tonic-gate 		}
27757c478bd9Sstevel@tonic-gate 	}
277608278a5eSRod Evans 	return (0);
27777c478bd9Sstevel@tonic-gate }
27787c478bd9Sstevel@tonic-gate 
27797c478bd9Sstevel@tonic-gate /*
27807c478bd9Sstevel@tonic-gate  * If an object specifies direct bindings (it contains a syminfo structure
27817c478bd9Sstevel@tonic-gate  * describing where each binding was established during link-editing, and the
27827c478bd9Sstevel@tonic-gate  * object was built -Bdirect), then look for the symbol in the specific object.
27837c478bd9Sstevel@tonic-gate  */
278408278a5eSRod Evans static int
lookup_sym_direct(Slookup * slp,Sresult * srp,uint_t * binfo,Syminfo * sip,Rt_map * lmp,int * in_nfavl)278508278a5eSRod Evans lookup_sym_direct(Slookup *slp, Sresult *srp, uint_t *binfo, Syminfo *sip,
27869aa23310Srie     Rt_map *lmp, int *in_nfavl)
27877c478bd9Sstevel@tonic-gate {
278808278a5eSRod Evans 	Rt_map	*dlmp, *clmp = slp->sl_cmap;
278908278a5eSRod Evans 	int	ret;
27907c478bd9Sstevel@tonic-gate 	Slookup	sl;
27917c478bd9Sstevel@tonic-gate 
27927c478bd9Sstevel@tonic-gate 	/*
27937c478bd9Sstevel@tonic-gate 	 * If a direct binding resolves to the definition of a copy relocated
27947c478bd9Sstevel@tonic-gate 	 * variable, it must be redirected to the copy (in the executable) that
27957c478bd9Sstevel@tonic-gate 	 * will eventually be made.  Typically, this redirection occurs in
27967c478bd9Sstevel@tonic-gate 	 * lookup_sym_interpose().  But, there's an edge condition.  If a
27977c478bd9Sstevel@tonic-gate 	 * directly bound executable contains pic code, there may be a
27987c478bd9Sstevel@tonic-gate 	 * reference to a definition that will eventually have a copy made.
27997c478bd9Sstevel@tonic-gate 	 * However, this copy relocation may not yet have occurred, because
28007c478bd9Sstevel@tonic-gate 	 * the relocation making this reference comes before the relocation
28017c478bd9Sstevel@tonic-gate 	 * that will create the copy.
28027c478bd9Sstevel@tonic-gate 	 * Under direct bindings, the syminfo indicates that a copy will be
28037c478bd9Sstevel@tonic-gate 	 * taken (SYMINFO_FLG_COPY).  This can only be set in an executable.
28047c478bd9Sstevel@tonic-gate 	 * Thus, the caller must be the executable, so bind to the destination
28057c478bd9Sstevel@tonic-gate 	 * of the copy within the executable.
28067c478bd9Sstevel@tonic-gate 	 */
28077c478bd9Sstevel@tonic-gate 	if (((slp->sl_flags & LKUP_COPY) == 0) &&
28087c478bd9Sstevel@tonic-gate 	    (sip->si_flags & SYMINFO_FLG_COPY)) {
28097c478bd9Sstevel@tonic-gate 		slp->sl_imap = LIST(clmp)->lm_head;
281008278a5eSRod Evans 
2811*80422cafSToomas Soome 		ret = SYMINTP(clmp)(slp, srp, binfo, in_nfavl);
2812*80422cafSToomas Soome 		if (ret != 0)
28137c478bd9Sstevel@tonic-gate 			*binfo |= (DBG_BINFO_DIRECT | DBG_BINFO_COPYREF);
281408278a5eSRod Evans 		return (ret);
28157c478bd9Sstevel@tonic-gate 	}
28167c478bd9Sstevel@tonic-gate 
28177c478bd9Sstevel@tonic-gate 	/*
2818efb9e8b8Srie 	 * If we need to directly bind to our parent, start looking in each
2819efb9e8b8Srie 	 * callers link map.
28207c478bd9Sstevel@tonic-gate 	 */
28217c478bd9Sstevel@tonic-gate 	sl = *slp;
28227c478bd9Sstevel@tonic-gate 	sl.sl_flags |= LKUP_DIRECT;
282308278a5eSRod Evans 	ret = 0;
28247c478bd9Sstevel@tonic-gate 
28257c478bd9Sstevel@tonic-gate 	if (sip->si_boundto == SYMINFO_BT_PARENT) {
2826cce0e03bSab 		Aliste		idx1;
2827cce0e03bSab 		Bnd_desc	*bdp;
2828cce0e03bSab 		Grp_hdl		*ghp;
28297c478bd9Sstevel@tonic-gate 
2830efb9e8b8Srie 		/*
2831efb9e8b8Srie 		 * Determine the parent of this explicit dependency from its
2832efb9e8b8Srie 		 * CALLERS()'s list.
2833efb9e8b8Srie 		 */
2834cce0e03bSab 		for (APLIST_TRAVERSE(CALLERS(clmp), idx1, bdp)) {
2835cce0e03bSab 			sl.sl_imap = lmp = bdp->b_caller;
2836*80422cafSToomas Soome 			ret = SYMINTP(lmp)(&sl, srp, binfo, in_nfavl);
2837*80422cafSToomas Soome 			if (ret != 0)
2838efb9e8b8Srie 				goto found;
2839efb9e8b8Srie 		}
2840efb9e8b8Srie 
2841efb9e8b8Srie 		/*
2842efb9e8b8Srie 		 * A caller can also be defined as the parent of a dlopen()
2843efb9e8b8Srie 		 * call.  Determine whether this object has any handles.  The
2844efb9e8b8Srie 		 * dependencies maintained with the handle represent the
2845efb9e8b8Srie 		 * explicit dependencies of the dlopen()'ed object, and the
2846efb9e8b8Srie 		 * calling parent.
2847efb9e8b8Srie 		 */
2848cce0e03bSab 		for (APLIST_TRAVERSE(HANDLES(clmp), idx1, ghp)) {
2849efb9e8b8Srie 			Grp_desc	*gdp;
2850cce0e03bSab 			Aliste		idx2;
2851efb9e8b8Srie 
2852cce0e03bSab 			for (ALIST_TRAVERSE(ghp->gh_depends, idx2, gdp)) {
2853efb9e8b8Srie 				if ((gdp->gd_flags & GPD_PARENT) == 0)
2854efb9e8b8Srie 					continue;
2855efb9e8b8Srie 				sl.sl_imap = lmp = gdp->gd_depend;
2856*80422cafSToomas Soome 				ret = SYMINTP(lmp)(&sl, srp, binfo, in_nfavl);
2857*80422cafSToomas Soome 				if (ret != 0)
2858efb9e8b8Srie 					goto found;
2859efb9e8b8Srie 			}
28607c478bd9Sstevel@tonic-gate 		}
28617c478bd9Sstevel@tonic-gate 	} else {
28627c478bd9Sstevel@tonic-gate 		/*
28637c478bd9Sstevel@tonic-gate 		 * If we need to direct bind to anything else look in the
28647c478bd9Sstevel@tonic-gate 		 * link map associated with this symbol reference.
28657c478bd9Sstevel@tonic-gate 		 */
28667c478bd9Sstevel@tonic-gate 		if (sip->si_boundto == SYMINFO_BT_SELF)
28677c478bd9Sstevel@tonic-gate 			sl.sl_imap = lmp = clmp;
28687c478bd9Sstevel@tonic-gate 		else
28697c478bd9Sstevel@tonic-gate 			sl.sl_imap = lmp;
28707c478bd9Sstevel@tonic-gate 
28717c478bd9Sstevel@tonic-gate 		if (lmp)
287208278a5eSRod Evans 			ret = SYMINTP(lmp)(&sl, srp, binfo, in_nfavl);
28737c478bd9Sstevel@tonic-gate 	}
2874efb9e8b8Srie found:
287508278a5eSRod Evans 	if (ret)
28767c478bd9Sstevel@tonic-gate 		*binfo |= DBG_BINFO_DIRECT;
28777c478bd9Sstevel@tonic-gate 
28787c478bd9Sstevel@tonic-gate 	/*
2879adbfe822Srie 	 * If a reference to a directly bound symbol can't be satisfied, then
2880adbfe822Srie 	 * determine whether an interposer can provide the missing symbol.  If
2881adbfe822Srie 	 * a reference to a directly bound symbol is satisfied, then determine
2882adbfe822Srie 	 * whether that object can be interposed upon for this symbol.
28837c478bd9Sstevel@tonic-gate 	 */
288408278a5eSRod Evans 	dlmp = srp->sr_dmap;
288508278a5eSRod Evans 	if ((ret == 0) || (dlmp && (LIST(dlmp)->lm_head != dlmp) &&
288608278a5eSRod Evans 	    (LIST(dlmp) == LIST(clmp)))) {
288708278a5eSRod Evans 		if (lookup_sym_interpose(slp, srp, binfo, in_nfavl))
288808278a5eSRod Evans 			return (1);
28897c478bd9Sstevel@tonic-gate 	}
28907c478bd9Sstevel@tonic-gate 
289108278a5eSRod Evans 	return (ret);
28927c478bd9Sstevel@tonic-gate }
28937c478bd9Sstevel@tonic-gate 
289408278a5eSRod Evans static int
core_lookup_sym(Rt_map * ilmp,Slookup * slp,Sresult * srp,uint_t * binfo,Aliste off,int * in_nfavl)289508278a5eSRod Evans core_lookup_sym(Rt_map *ilmp, Slookup *slp, Sresult *srp, uint_t *binfo,
28969aa23310Srie     Aliste off, int *in_nfavl)
28977c478bd9Sstevel@tonic-gate {
28987c478bd9Sstevel@tonic-gate 	Rt_map	*lmp;
28997c478bd9Sstevel@tonic-gate 
29007c478bd9Sstevel@tonic-gate 	/*
29017c478bd9Sstevel@tonic-gate 	 * Copy relocations should start their search after the head of the
29027c478bd9Sstevel@tonic-gate 	 * main link-map control list.
29037c478bd9Sstevel@tonic-gate 	 */
2904cce0e03bSab 	if ((off == ALIST_OFF_DATA) && (slp->sl_flags & LKUP_COPY) && ilmp)
2905cb511613SAli Bahrami 		lmp = NEXT_RT_MAP(ilmp);
29067c478bd9Sstevel@tonic-gate 	else
29077c478bd9Sstevel@tonic-gate 		lmp = ilmp;
29087c478bd9Sstevel@tonic-gate 
2909cb511613SAli Bahrami 	for (; lmp; lmp = NEXT_RT_MAP(lmp)) {
291060758829Srie 		if (callable(slp->sl_cmap, lmp, 0, slp->sl_flags)) {
29117c478bd9Sstevel@tonic-gate 
29127c478bd9Sstevel@tonic-gate 			slp->sl_imap = lmp;
291308278a5eSRod Evans 			if ((SYMINTP(lmp)(slp, srp, binfo, in_nfavl)) ||
291437ffaf83SRod Evans 			    (*binfo & BINFO_MSK_TRYAGAIN))
291508278a5eSRod Evans 				return (1);
29167c478bd9Sstevel@tonic-gate 		}
29177c478bd9Sstevel@tonic-gate 	}
291808278a5eSRod Evans 	return (0);
29197c478bd9Sstevel@tonic-gate }
29207c478bd9Sstevel@tonic-gate 
292108278a5eSRod Evans static int
rescan_lazy_find_sym(Rt_map * ilmp,Slookup * slp,Sresult * srp,uint_t * binfo,int * in_nfavl)292208278a5eSRod Evans rescan_lazy_find_sym(Rt_map *ilmp, Slookup *slp, Sresult *srp, uint_t *binfo,
29239aa23310Srie     int *in_nfavl)
29247c478bd9Sstevel@tonic-gate {
29257c478bd9Sstevel@tonic-gate 	Rt_map	*lmp;
29267c478bd9Sstevel@tonic-gate 
2927cb511613SAli Bahrami 	for (lmp = ilmp; lmp; lmp = NEXT_RT_MAP(lmp)) {
29287c478bd9Sstevel@tonic-gate 		if (LAZY(lmp) == 0)
29297c478bd9Sstevel@tonic-gate 			continue;
293060758829Srie 		if (callable(slp->sl_cmap, lmp, 0, slp->sl_flags)) {
29317c478bd9Sstevel@tonic-gate 
29327c478bd9Sstevel@tonic-gate 			slp->sl_imap = lmp;
293308278a5eSRod Evans 			if (elf_lazy_find_sym(slp, srp, binfo, in_nfavl))
293408278a5eSRod Evans 				return (1);
29357c478bd9Sstevel@tonic-gate 		}
29367c478bd9Sstevel@tonic-gate 	}
293708278a5eSRod Evans 	return (0);
29387c478bd9Sstevel@tonic-gate }
29397c478bd9Sstevel@tonic-gate 
294008278a5eSRod Evans static int
_lookup_sym(Slookup * slp,Sresult * srp,uint_t * binfo,int * in_nfavl)294108278a5eSRod Evans _lookup_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl)
29427c478bd9Sstevel@tonic-gate {
29437c478bd9Sstevel@tonic-gate 	const char	*name = slp->sl_name;
29447c478bd9Sstevel@tonic-gate 	Rt_map		*clmp = slp->sl_cmap;
2945dae2dfb7Srie 	Lm_list		*lml = LIST(clmp);
29467c478bd9Sstevel@tonic-gate 	Rt_map		*ilmp = slp->sl_imap, *lmp;
29477c478bd9Sstevel@tonic-gate 	ulong_t		rsymndx;
294808278a5eSRod Evans 	int		ret;
29497c478bd9Sstevel@tonic-gate 	Syminfo		*sip;
29507c478bd9Sstevel@tonic-gate 	Slookup		sl;
29517c478bd9Sstevel@tonic-gate 
29527c478bd9Sstevel@tonic-gate 	/*
29537c478bd9Sstevel@tonic-gate 	 * Search the initial link map for the required symbol (this category is
29547c478bd9Sstevel@tonic-gate 	 * selected by dlsym(), where individual link maps are searched for a
29557c478bd9Sstevel@tonic-gate 	 * required symbol.  Therefore, we know we have permission to look at
29567c478bd9Sstevel@tonic-gate 	 * the link map).
29577c478bd9Sstevel@tonic-gate 	 */
295860758829Srie 	if (slp->sl_flags & LKUP_FIRST)
295908278a5eSRod Evans 		return (SYMINTP(ilmp)(slp, srp, binfo, in_nfavl));
29607c478bd9Sstevel@tonic-gate 
29617c478bd9Sstevel@tonic-gate 	/*
29627c478bd9Sstevel@tonic-gate 	 * Determine whether this lookup can be satisfied by an objects direct,
29637c478bd9Sstevel@tonic-gate 	 * or lazy binding information.  This is triggered by a relocation from
29647c478bd9Sstevel@tonic-gate 	 * the object (hence rsymndx is set).
29657c478bd9Sstevel@tonic-gate 	 */
29667c478bd9Sstevel@tonic-gate 	if (((rsymndx = slp->sl_rsymndx) != 0) &&
2967aa736cbeSrie 	    ((sip = SYMINFO(clmp)) != NULL)) {
2968dae2dfb7Srie 		uint_t	bound;
2969dae2dfb7Srie 
29707c478bd9Sstevel@tonic-gate 		/*
29717c478bd9Sstevel@tonic-gate 		 * Find the corresponding Syminfo entry for the original
29727c478bd9Sstevel@tonic-gate 		 * referencing symbol.
29737c478bd9Sstevel@tonic-gate 		 */
29747c478bd9Sstevel@tonic-gate 		/* LINTED */
29757c478bd9Sstevel@tonic-gate 		sip = (Syminfo *)((char *)sip + (rsymndx * SYMINENT(clmp)));
2976dae2dfb7Srie 		bound = sip->si_boundto;
2977dae2dfb7Srie 
2978dae2dfb7Srie 		/*
2979dae2dfb7Srie 		 * Identify any EXTERN or PARENT references for ldd(1).
2980dae2dfb7Srie 		 */
2981dae2dfb7Srie 		if ((lml->lm_flags & LML_FLG_TRC_WARN) &&
2982dae2dfb7Srie 		    (bound > SYMINFO_BT_LOWRESERVE)) {
2983dae2dfb7Srie 			if (bound == SYMINFO_BT_PARENT)
2984dae2dfb7Srie 				*binfo |= DBG_BINFO_REF_PARENT;
2985dae2dfb7Srie 			if (bound == SYMINFO_BT_EXTERN)
2986dae2dfb7Srie 				*binfo |= DBG_BINFO_REF_EXTERN;
2987dae2dfb7Srie 		}
29887c478bd9Sstevel@tonic-gate 
29897c478bd9Sstevel@tonic-gate 		/*
29907c478bd9Sstevel@tonic-gate 		 * If the symbol information indicates a direct binding,
29917c478bd9Sstevel@tonic-gate 		 * determine the link map that is required to satisfy the
29927c478bd9Sstevel@tonic-gate 		 * binding.  Note, if the dependency can not be found, but a
29937c478bd9Sstevel@tonic-gate 		 * direct binding isn't required, we will still fall through
29947c478bd9Sstevel@tonic-gate 		 * to perform any default symbol search.
29957c478bd9Sstevel@tonic-gate 		 */
29967c478bd9Sstevel@tonic-gate 		if (sip->si_flags & SYMINFO_FLG_DIRECT) {
29977c478bd9Sstevel@tonic-gate 
29987c478bd9Sstevel@tonic-gate 			lmp = 0;
29997c478bd9Sstevel@tonic-gate 			if (bound < SYMINFO_BT_LOWRESERVE)
30009aa23310Srie 				lmp = elf_lazy_load(clmp, slp, bound,
30012017c965SRod Evans 				    name, 0, NULL, in_nfavl);
30027c478bd9Sstevel@tonic-gate 
30037c478bd9Sstevel@tonic-gate 			/*
30047c478bd9Sstevel@tonic-gate 			 * If direct bindings have been disabled, and this isn't
30057c478bd9Sstevel@tonic-gate 			 * a translator, skip any direct binding now that we've
300660758829Srie 			 * ensured the resolving object has been loaded.
30077c478bd9Sstevel@tonic-gate 			 *
30087c478bd9Sstevel@tonic-gate 			 * If we need to direct bind to anything, we look in
30097c478bd9Sstevel@tonic-gate 			 * ourselves, our parent, or in the link map we've just
30107c478bd9Sstevel@tonic-gate 			 * loaded.  Otherwise, even though we may have lazily
30117c478bd9Sstevel@tonic-gate 			 * loaded an object we still continue to search for
30127c478bd9Sstevel@tonic-gate 			 * symbols from the head of the link map list.
30137c478bd9Sstevel@tonic-gate 			 */
30147c478bd9Sstevel@tonic-gate 			if (((FLAGS(clmp) & FLG_RT_TRANS) ||
3015dae2dfb7Srie 			    (((lml->lm_tflags & LML_TFLG_NODIRECT) == 0) &&
3016dae2dfb7Srie 			    ((slp->sl_flags & LKUP_SINGLETON) == 0))) &&
30179a411307Srie 			    ((FLAGS1(clmp) & FL1_RT_DIRECT) ||
30187c478bd9Sstevel@tonic-gate 			    (sip->si_flags & SYMINFO_FLG_DIRECTBIND))) {
301908278a5eSRod Evans 				ret = lookup_sym_direct(slp, srp, binfo,
30209aa23310Srie 				    sip, lmp, in_nfavl);
30217c478bd9Sstevel@tonic-gate 
30227c478bd9Sstevel@tonic-gate 				/*
302360758829Srie 				 * Determine whether this direct binding has
302460758829Srie 				 * been rejected.  If we've bound to a singleton
302560758829Srie 				 * without following a singleton search, then
302660758829Srie 				 * return.  The caller detects this condition
302760758829Srie 				 * and will trigger a new singleton search.
302860758829Srie 				 *
302960758829Srie 				 * For any other rejection (such as binding to
303060758829Srie 				 * a symbol labeled as nodirect - presumably
303160758829Srie 				 * because the symbol definition has been
303260758829Srie 				 * changed since the referring object was last
303360758829Srie 				 * built), fall through to a standard symbol
30347c478bd9Sstevel@tonic-gate 				 * search.
30357c478bd9Sstevel@tonic-gate 				 */
303637ffaf83SRod Evans 				if (((*binfo & BINFO_MSK_REJECTED) == 0) ||
303737ffaf83SRod Evans 				    (*binfo & BINFO_MSK_TRYAGAIN))
303808278a5eSRod Evans 					return (ret);
303960758829Srie 
304037ffaf83SRod Evans 				*binfo &= ~BINFO_MSK_REJECTED;
30417c478bd9Sstevel@tonic-gate 			}
30427c478bd9Sstevel@tonic-gate 		}
30437c478bd9Sstevel@tonic-gate 	}
30447c478bd9Sstevel@tonic-gate 
304560758829Srie 	/*
304660758829Srie 	 * Duplicate the lookup information, as we'll need to modify this
304760758829Srie 	 * information for some of the following searches.
304860758829Srie 	 */
30497c478bd9Sstevel@tonic-gate 	sl = *slp;
30507c478bd9Sstevel@tonic-gate 
30517c478bd9Sstevel@tonic-gate 	/*
30527c478bd9Sstevel@tonic-gate 	 * If the referencing object has the DF_SYMBOLIC flag set, look in the
30537c478bd9Sstevel@tonic-gate 	 * referencing object for the symbol first.  Failing that, fall back to
30547c478bd9Sstevel@tonic-gate 	 * our generic search.
30557c478bd9Sstevel@tonic-gate 	 */
305660758829Srie 	if ((FLAGS1(clmp) & FL1_RT_SYMBOLIC) &&
305760758829Srie 	    ((sl.sl_flags & LKUP_SINGLETON) == 0)) {
305808278a5eSRod Evans 
30597c478bd9Sstevel@tonic-gate 		sl.sl_imap = clmp;
306008278a5eSRod Evans 		if (SYMINTP(clmp)(&sl, srp, binfo, in_nfavl)) {
306108278a5eSRod Evans 			Rt_map	*dlmp = srp->sr_dmap;
306208278a5eSRod Evans 			ulong_t	dsymndx = (((ulong_t)srp->sr_sym -
306308278a5eSRod Evans 			    (ulong_t)SYMTAB(dlmp)) / SYMENT(dlmp));
30649a411307Srie 
30659a411307Srie 			/*
30669a411307Srie 			 * Make sure this symbol hasn't explicitly been defined
30679a411307Srie 			 * as nodirect.
30689a411307Srie 			 */
306908278a5eSRod Evans 			if (((sip = SYMINFO(dlmp)) == 0) ||
30709a411307Srie 			    /* LINTED */
30719a411307Srie 			    ((sip = (Syminfo *)((char *)sip +
307208278a5eSRod Evans 			    (dsymndx * SYMINENT(dlmp)))) == 0) ||
30739a411307Srie 			    ((sip->si_flags & SYMINFO_FLG_NOEXTDIRECT) == 0))
307408278a5eSRod Evans 				return (1);
30759a411307Srie 		}
30767c478bd9Sstevel@tonic-gate 	}
30777c478bd9Sstevel@tonic-gate 
307860758829Srie 	sl.sl_flags |= LKUP_STANDARD;
307960758829Srie 
30807c478bd9Sstevel@tonic-gate 	/*
30817c478bd9Sstevel@tonic-gate 	 * If this lookup originates from a standard relocation, then traverse
308260758829Srie 	 * all link-map control lists, inspecting any object that is available
308360758829Srie 	 * to this caller.  Otherwise, traverse the link-map control list
308460758829Srie 	 * associated with the caller.
30857c478bd9Sstevel@tonic-gate 	 */
308660758829Srie 	if (sl.sl_flags & LKUP_STDRELOC) {
30877c478bd9Sstevel@tonic-gate 		Aliste	off;
30887c478bd9Sstevel@tonic-gate 		Lm_cntl	*lmc;
30897c478bd9Sstevel@tonic-gate 
309008278a5eSRod Evans 		ret = 0;
30917c478bd9Sstevel@tonic-gate 
3092dae2dfb7Srie 		for (ALIST_TRAVERSE_BY_OFFSET(lml->lm_lists, off, lmc)) {
309308278a5eSRod Evans 			if (((ret = core_lookup_sym(lmc->lc_head, &sl, srp,
309408278a5eSRod Evans 			    binfo, off, in_nfavl)) != 0) ||
309537ffaf83SRod Evans 			    (*binfo & BINFO_MSK_TRYAGAIN))
30967c478bd9Sstevel@tonic-gate 				break;
30977c478bd9Sstevel@tonic-gate 		}
30987c478bd9Sstevel@tonic-gate 	} else
309908278a5eSRod Evans 		ret = core_lookup_sym(ilmp, &sl, srp, binfo, ALIST_OFF_DATA,
31009aa23310Srie 		    in_nfavl);
310160758829Srie 
310260758829Srie 	/*
310337ffaf83SRod Evans 	 * If a symbol binding should be retried, return so that the search can
310437ffaf83SRod Evans 	 * be repeated.
310560758829Srie 	 */
310637ffaf83SRod Evans 	if (*binfo & BINFO_MSK_TRYAGAIN)
310708278a5eSRod Evans 		return (0);
31087c478bd9Sstevel@tonic-gate 
31097c478bd9Sstevel@tonic-gate 	/*
31107c478bd9Sstevel@tonic-gate 	 * To allow transitioning into a world of lazy loading dependencies see
31117c478bd9Sstevel@tonic-gate 	 * if this link map contains objects that have lazy dependencies still
31127c478bd9Sstevel@tonic-gate 	 * outstanding.  If so, and we haven't been able to locate a non-weak
31137c478bd9Sstevel@tonic-gate 	 * symbol reference, start bringing in any lazy dependencies to see if
31147c478bd9Sstevel@tonic-gate 	 * the reference can be satisfied.  Use of dlsym(RTLD_PROBE) sets the
311575e7992aSrie 	 * LKUP_NOFALLBACK flag, and this flag disables this fall back.
31167c478bd9Sstevel@tonic-gate 	 */
311708278a5eSRod Evans 	if ((ret == 0) && ((sl.sl_flags & LKUP_NOFALLBACK) == 0)) {
31187c478bd9Sstevel@tonic-gate 		if ((lmp = ilmp) == 0)
31197c478bd9Sstevel@tonic-gate 			lmp = LIST(clmp)->lm_head;
312075e7992aSrie 
3121dae2dfb7Srie 		lml = LIST(lmp);
3122dae2dfb7Srie 		if ((sl.sl_flags & LKUP_WEAK) || (lml->lm_lazy == 0))
312367d74cc3SToomas Soome 			return (0);
31247c478bd9Sstevel@tonic-gate 
3125dae2dfb7Srie 		DBG_CALL(Dbg_syms_lazy_rescan(lml, name));
31267c478bd9Sstevel@tonic-gate 
31277c478bd9Sstevel@tonic-gate 		/*
31287c478bd9Sstevel@tonic-gate 		 * If this request originated from a dlsym(RTLD_NEXT) then start
31297c478bd9Sstevel@tonic-gate 		 * looking for dependencies from the caller, otherwise use the
31307c478bd9Sstevel@tonic-gate 		 * initial link-map.
31317c478bd9Sstevel@tonic-gate 		 */
313260758829Srie 		if (sl.sl_flags & LKUP_NEXT)
313308278a5eSRod Evans 			ret = rescan_lazy_find_sym(clmp, &sl, srp, binfo,
31342017c965SRod Evans 			    in_nfavl);
31357c478bd9Sstevel@tonic-gate 		else {
3136cce0e03bSab 			Aliste	idx;
31377c478bd9Sstevel@tonic-gate 			Lm_cntl	*lmc;
31387c478bd9Sstevel@tonic-gate 
3139dae2dfb7Srie 			for (ALIST_TRAVERSE(lml->lm_lists, idx, lmc)) {
314075e7992aSrie 				sl.sl_flags |= LKUP_NOFALLBACK;
3141*80422cafSToomas Soome 				ret = rescan_lazy_find_sym(lmc->lc_head,
3142*80422cafSToomas Soome 				    &sl, srp, binfo, in_nfavl);
3143*80422cafSToomas Soome 				if (ret != 0)
31447c478bd9Sstevel@tonic-gate 					break;
31457c478bd9Sstevel@tonic-gate 			}
31467c478bd9Sstevel@tonic-gate 		}
31477c478bd9Sstevel@tonic-gate 	}
314808278a5eSRod Evans 	return (ret);
314960758829Srie }
315060758829Srie 
315160758829Srie /*
315260758829Srie  * Symbol lookup routine.  Takes an ELF symbol name, and a list of link maps to
315360758829Srie  * search.  If successful, return a pointer to the symbol table entry, a
315460758829Srie  * pointer to the link map of the enclosing object, and information relating
315560758829Srie  * to the type of binding.  Else return a null pointer.
315660758829Srie  */
315708278a5eSRod Evans int
lookup_sym(Slookup * slp,Sresult * srp,uint_t * binfo,int * in_nfavl)315808278a5eSRod Evans lookup_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl)
315960758829Srie {
316060758829Srie 	Rt_map		*clmp = slp->sl_cmap;
316108278a5eSRod Evans 	Sym		*rsym = slp->sl_rsym;
316208278a5eSRod Evans 	uchar_t		rtype = slp->sl_rtype, vis;
316308278a5eSRod Evans 	int		ret, mode;
316460758829Srie 
316560758829Srie 	if (slp->sl_hash == 0)
316675e7992aSrie 		slp->sl_hash = elf_hash(slp->sl_name);
316760758829Srie 	*binfo = 0;
316860758829Srie 
316960758829Srie 	if (rsym) {
317008278a5eSRod Evans 		vis = ELF_ST_VISIBILITY(rsym->st_other);
317108278a5eSRod Evans 
317208278a5eSRod Evans 		/*
317308278a5eSRod Evans 		 * Symbols that are defined as protected, or hidden, within an
317408278a5eSRod Evans 		 * object usually have any relocation references from within
317508278a5eSRod Evans 		 * the same object bound at link-edit time.  Therefore, ld.so.1
317608278a5eSRod Evans 		 * is not involved.  However, if a reference is to a
317708278a5eSRod Evans 		 * capabilities symbol, this reference must be resolved at
317808278a5eSRod Evans 		 * runtime.  In this case look directly within the calling
317908278a5eSRod Evans 		 * object, and only within the calling object, for these
318008278a5eSRod Evans 		 * symbols.  Note, an object may still use dlsym() to search
318108278a5eSRod Evans 		 * externally for a symbol which is defined as protected within
318208278a5eSRod Evans 		 * the same object.
318308278a5eSRod Evans 		 */
318408278a5eSRod Evans 		if ((rsym->st_shndx != SHN_UNDEF) &&
318508278a5eSRod Evans 		    ((slp->sl_flags & LKUP_DLSYM) == 0) &&
318608278a5eSRod Evans 		    ((vis == STV_PROTECTED) || (vis == STV_HIDDEN))) {
318708278a5eSRod Evans 			slp->sl_imap = clmp;
318808278a5eSRod Evans 			return (SYMINTP(clmp)(slp, srp, binfo, in_nfavl));
318908278a5eSRod Evans 		}
319008278a5eSRod Evans 
319108278a5eSRod Evans 		/*
319208278a5eSRod Evans 		 * Establish any state that might be associated with a symbol
319308278a5eSRod Evans 		 * reference.
319408278a5eSRod Evans 		 */
319560758829Srie 		if ((slp->sl_flags & LKUP_STDRELOC) &&
319660758829Srie 		    (ELF_ST_BIND(rsym->st_info) == STB_WEAK))
319760758829Srie 			slp->sl_flags |= LKUP_WEAK;
319860758829Srie 
319908278a5eSRod Evans 		if (vis == STV_SINGLETON)
320060758829Srie 			slp->sl_flags |= LKUP_SINGLETON;
320160758829Srie 	}
320260758829Srie 
320360758829Srie 	/*
320460758829Srie 	 * Establish any lookup state required for this type of relocation.
320560758829Srie 	 */
320660758829Srie 	if ((slp->sl_flags & LKUP_STDRELOC) && rtype) {
320760758829Srie 		if (rtype == M_R_COPY)
320860758829Srie 			slp->sl_flags |= LKUP_COPY;
320960758829Srie 
321060758829Srie 		if (rtype != M_R_JMP_SLOT)
321160758829Srie 			slp->sl_flags |= LKUP_SPEC;
321260758829Srie 	}
321360758829Srie 
321460758829Srie 	/*
321560758829Srie 	 * Under ldd -w, any unresolved weak references are diagnosed.  Set the
321660758829Srie 	 * symbol binding as global to trigger a relocation error if the symbol
321760758829Srie 	 * can not be found.
321860758829Srie 	 */
321960758829Srie 	if (rsym) {
322060758829Srie 		if (LIST(slp->sl_cmap)->lm_flags & LML_FLG_TRC_NOUNRESWEAK)
322160758829Srie 			slp->sl_bind = STB_GLOBAL;
322260758829Srie 		else if ((slp->sl_bind = ELF_ST_BIND(rsym->st_info)) ==
322360758829Srie 		    STB_WEAK)
322460758829Srie 			slp->sl_flags |= LKUP_WEAK;
322560758829Srie 	}
322660758829Srie 
322737ffaf83SRod Evans 	/*
322837ffaf83SRod Evans 	 * Save the callers MODE().
322937ffaf83SRod Evans 	 */
323037ffaf83SRod Evans 	mode = MODE(clmp);
323137ffaf83SRod Evans 
323260758829Srie 	/*
323360758829Srie 	 * Carry out an initial symbol search.  This search takes into account
323460758829Srie 	 * all the modes of the requested search.
323560758829Srie 	 */
323608278a5eSRod Evans 	if (((ret = _lookup_sym(slp, srp, binfo, in_nfavl)) == 0) &&
323737ffaf83SRod Evans 	    (*binfo & BINFO_MSK_TRYAGAIN)) {
323860758829Srie 		Slookup	sl = *slp;
323960758829Srie 
324060758829Srie 		/*
324137ffaf83SRod Evans 		 * Try the symbol search again.  This retry can be necessary if:
324237ffaf83SRod Evans 		 *
32432017c965SRod Evans 		 *  -	a binding has been rejected because of binding to a
324437ffaf83SRod Evans 		 *	singleton without going through a singleton search.
32452017c965SRod Evans 		 *  -	a group binding has resulted in binding to a symbol
324637ffaf83SRod Evans 		 *	that indicates no-direct binding.
324737ffaf83SRod Evans 		 *
324837ffaf83SRod Evans 		 * Reset the lookup data, and try again.
324960758829Srie 		 */
325060758829Srie 		sl.sl_imap = LIST(sl.sl_cmap)->lm_head;
325160758829Srie 		sl.sl_flags &= ~(LKUP_FIRST | LKUP_SELF | LKUP_NEXT);
325260758829Srie 		sl.sl_rsymndx = 0;
325337ffaf83SRod Evans 
325437ffaf83SRod Evans 		if (*binfo & BINFO_REJSINGLE)
325537ffaf83SRod Evans 			sl.sl_flags |= LKUP_SINGLETON;
325637ffaf83SRod Evans 		if (*binfo & BINFO_REJGROUP) {
325737ffaf83SRod Evans 			sl.sl_flags |= LKUP_WORLD;
325837ffaf83SRod Evans 			mode |= RTLD_WORLD;
325937ffaf83SRod Evans 		}
326037ffaf83SRod Evans 		*binfo &= ~BINFO_MSK_REJECTED;
326137ffaf83SRod Evans 
326208278a5eSRod Evans 		ret = _lookup_sym(&sl, srp, binfo, in_nfavl);
326360758829Srie 	}
32647c478bd9Sstevel@tonic-gate 
32657c478bd9Sstevel@tonic-gate 	/*
32667c478bd9Sstevel@tonic-gate 	 * If the caller is restricted to a symbol search within its group,
32677c478bd9Sstevel@tonic-gate 	 * determine if it is necessary to follow a binding from outside of
32687c478bd9Sstevel@tonic-gate 	 * the group.
32697c478bd9Sstevel@tonic-gate 	 */
327008278a5eSRod Evans 	if (((mode & (RTLD_GROUP | RTLD_WORLD)) == RTLD_GROUP) &&
327108278a5eSRod Evans 	    (lookup_sym_interpose(slp, srp, binfo, in_nfavl)))
327208278a5eSRod Evans 		return (1);
32737c478bd9Sstevel@tonic-gate 
327408278a5eSRod Evans 	return (ret);
32757c478bd9Sstevel@tonic-gate }
32767c478bd9Sstevel@tonic-gate 
32777c478bd9Sstevel@tonic-gate /*
32787c478bd9Sstevel@tonic-gate  * Associate a binding descriptor with a caller and its dependency, or update
32797c478bd9Sstevel@tonic-gate  * an existing descriptor.
32807c478bd9Sstevel@tonic-gate  */
32817c478bd9Sstevel@tonic-gate int
bind_one(Rt_map * clmp,Rt_map * dlmp,uint_t flags)32825aefb655Srie bind_one(Rt_map *clmp, Rt_map *dlmp, uint_t flags)
32837c478bd9Sstevel@tonic-gate {
3284cce0e03bSab 	Bnd_desc	*bdp;
3285cce0e03bSab 	Aliste		idx;
32867c478bd9Sstevel@tonic-gate 	int		found = ALE_CREATE;
32877c478bd9Sstevel@tonic-gate 
32887c478bd9Sstevel@tonic-gate 	/*
32897c478bd9Sstevel@tonic-gate 	 * Determine whether a binding descriptor already exists between the
32907c478bd9Sstevel@tonic-gate 	 * two objects.
32917c478bd9Sstevel@tonic-gate 	 */
3292cce0e03bSab 	for (APLIST_TRAVERSE(DEPENDS(clmp), idx, bdp)) {
32937c478bd9Sstevel@tonic-gate 		if (bdp->b_depend == dlmp) {
32947c478bd9Sstevel@tonic-gate 			found = ALE_EXISTS;
32957c478bd9Sstevel@tonic-gate 			break;
32967c478bd9Sstevel@tonic-gate 		}
32977c478bd9Sstevel@tonic-gate 	}
32987c478bd9Sstevel@tonic-gate 
32997c478bd9Sstevel@tonic-gate 	if (found == ALE_CREATE) {
33007c478bd9Sstevel@tonic-gate 		/*
33017c478bd9Sstevel@tonic-gate 		 * Create a new binding descriptor.
33027c478bd9Sstevel@tonic-gate 		 */
330337ffaf83SRod Evans 		if ((bdp = malloc(sizeof (Bnd_desc))) == NULL)
33047c478bd9Sstevel@tonic-gate 			return (0);
33057c478bd9Sstevel@tonic-gate 
33067c478bd9Sstevel@tonic-gate 		bdp->b_caller = clmp;
33077c478bd9Sstevel@tonic-gate 		bdp->b_depend = dlmp;
33087c478bd9Sstevel@tonic-gate 		bdp->b_flags = 0;
33097c478bd9Sstevel@tonic-gate 
33107c478bd9Sstevel@tonic-gate 		/*
33117c478bd9Sstevel@tonic-gate 		 * Append the binding descriptor to the caller and the
33127c478bd9Sstevel@tonic-gate 		 * dependency.
33137c478bd9Sstevel@tonic-gate 		 */
331456deab07SRod Evans 		if (aplist_append(&DEPENDS(clmp), bdp, AL_CNT_DEPENDS) == NULL)
33157c478bd9Sstevel@tonic-gate 			return (0);
33167c478bd9Sstevel@tonic-gate 
331756deab07SRod Evans 		if (aplist_append(&CALLERS(dlmp), bdp, AL_CNT_CALLERS) == NULL)
33187c478bd9Sstevel@tonic-gate 			return (0);
33197c478bd9Sstevel@tonic-gate 	}
33207c478bd9Sstevel@tonic-gate 
33217c478bd9Sstevel@tonic-gate 	if ((found == ALE_CREATE) || ((bdp->b_flags & flags) != flags)) {
33227c478bd9Sstevel@tonic-gate 		bdp->b_flags |= flags;
33237c478bd9Sstevel@tonic-gate 
33247c478bd9Sstevel@tonic-gate 		if (flags & BND_REFER)
33257c478bd9Sstevel@tonic-gate 			FLAGS1(dlmp) |= FL1_RT_USED;
33267c478bd9Sstevel@tonic-gate 
33275aefb655Srie 		DBG_CALL(Dbg_file_bind_entry(LIST(clmp), bdp));
33287c478bd9Sstevel@tonic-gate 	}
33297c478bd9Sstevel@tonic-gate 	return (found);
33307c478bd9Sstevel@tonic-gate }
33317c478bd9Sstevel@tonic-gate 
33327c478bd9Sstevel@tonic-gate /*
33337c478bd9Sstevel@tonic-gate  * Cleanup after relocation processing.
33347c478bd9Sstevel@tonic-gate  */
33357c478bd9Sstevel@tonic-gate int
relocate_finish(Rt_map * lmp,APlist * bound,int ret)333656deab07SRod Evans relocate_finish(Rt_map *lmp, APlist *bound, int ret)
33377c478bd9Sstevel@tonic-gate {
33385aefb655Srie 	DBG_CALL(Dbg_reloc_run(lmp, 0, ret, DBG_REL_FINISH));
33397c478bd9Sstevel@tonic-gate 
33407c478bd9Sstevel@tonic-gate 	/*
33417c478bd9Sstevel@tonic-gate 	 * Establish bindings to all objects that have been bound to.
33427c478bd9Sstevel@tonic-gate 	 */
33437c478bd9Sstevel@tonic-gate 	if (bound) {
3344cce0e03bSab 		Rt_map	*_lmp;
33458a20d9f8Srie 		Word	used;
33467c478bd9Sstevel@tonic-gate 
33478a20d9f8Srie 		/*
33488a20d9f8Srie 		 * Only create bindings if the callers relocation was
33498a20d9f8Srie 		 * successful (ret != 0), otherwise the object will eventually
33508a20d9f8Srie 		 * be torn down.  Create these bindings if running under ldd(1)
33518a20d9f8Srie 		 * with the -U/-u options regardless of relocation errors, as
33528a20d9f8Srie 		 * the unused processing needs to traverse these bindings to
33538a20d9f8Srie 		 * diagnose unused objects.
33548a20d9f8Srie 		 */
33558a20d9f8Srie 		used = LIST(lmp)->lm_flags &
33568a20d9f8Srie 		    (LML_FLG_TRC_UNREF | LML_FLG_TRC_UNUSED);
33578a20d9f8Srie 
33588a20d9f8Srie 		if (ret || used) {
335956deab07SRod Evans 			Aliste	idx;
336056deab07SRod Evans 
3361cce0e03bSab 			for (APLIST_TRAVERSE(bound, idx, _lmp)) {
33628a20d9f8Srie 				if (bind_one(lmp, _lmp, BND_REFER) || used)
33638a20d9f8Srie 					continue;
33648a20d9f8Srie 
33658a20d9f8Srie 				ret = 0;
33668a20d9f8Srie 				break;
33677c478bd9Sstevel@tonic-gate 			}
33687c478bd9Sstevel@tonic-gate 		}
33697c478bd9Sstevel@tonic-gate 		free(bound);
33707c478bd9Sstevel@tonic-gate 	}
33717c478bd9Sstevel@tonic-gate 
337256deab07SRod Evans 	return (ret);
337356deab07SRod Evans }
337456deab07SRod Evans 
337556deab07SRod Evans /*
337656deab07SRod Evans  * Function to correct protection settings.  Segments are all mapped initially
337756deab07SRod Evans  * with permissions as given in the segment header.  We need to turn on write
337856deab07SRod Evans  * permissions on a text segment if there are any relocations against that
337956deab07SRod Evans  * segment, and then turn write permission back off again before returning
338056deab07SRod Evans  * control to the caller.  This function turns the permission on or off
338156deab07SRod Evans  * depending on the value of the permission argument.
338256deab07SRod Evans  */
338356deab07SRod Evans int
set_prot(Rt_map * lmp,mmapobj_result_t * mpp,int perm)338456deab07SRod Evans set_prot(Rt_map *lmp, mmapobj_result_t *mpp, int perm)
338556deab07SRod Evans {
338656deab07SRod Evans 	int	prot;
338756deab07SRod Evans 
33887c478bd9Sstevel@tonic-gate 	/*
338956deab07SRod Evans 	 * If this is an allocated image (ie. a relocatable object) we can't
339056deab07SRod Evans 	 * mprotect() anything.
33917c478bd9Sstevel@tonic-gate 	 */
339256deab07SRod Evans 	if (FLAGS(lmp) & FLG_RT_IMGALLOC)
339356deab07SRod Evans 		return (1);
33947c478bd9Sstevel@tonic-gate 
339556deab07SRod Evans 	DBG_CALL(Dbg_file_prot(lmp, perm));
339656deab07SRod Evans 
339756deab07SRod Evans 	if (perm)
339856deab07SRod Evans 		prot = mpp->mr_prot | PROT_WRITE;
339956deab07SRod Evans 	else
340056deab07SRod Evans 		prot = mpp->mr_prot & ~PROT_WRITE;
340156deab07SRod Evans 
340256deab07SRod Evans 	if (mprotect((void *)(uintptr_t)mpp->mr_addr,
340356deab07SRod Evans 	    mpp->mr_msize, prot) == -1) {
340456deab07SRod Evans 		int	err = errno;
340556deab07SRod Evans 		eprintf(LIST(lmp), ERR_FATAL, MSG_INTL(MSG_SYS_MPROT),
340656deab07SRod Evans 		    NAME(lmp), strerror(err));
340756deab07SRod Evans 		return (0);
340856deab07SRod Evans 	}
340956deab07SRod Evans 	mpp->mr_prot = prot;
341056deab07SRod Evans 	return (1);
34117c478bd9Sstevel@tonic-gate }
3412