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 /* 2356deab07SRod Evans * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277257d1b4Sraf /* 287257d1b4Sraf * Copyright (c) 1988 AT&T 297257d1b4Sraf * All Rights Reserved 307257d1b4Sraf */ 317257d1b4Sraf 327c478bd9Sstevel@tonic-gate #include <string.h> 337c478bd9Sstevel@tonic-gate #include <stdio.h> 347c478bd9Sstevel@tonic-gate #include <unistd.h> 357c478bd9Sstevel@tonic-gate #include <sys/stat.h> 367c478bd9Sstevel@tonic-gate #include <sys/mman.h> 3756deab07SRod Evans #include <sys/debug.h> 387c478bd9Sstevel@tonic-gate #include <fcntl.h> 397c478bd9Sstevel@tonic-gate #include <limits.h> 407c478bd9Sstevel@tonic-gate #include <dlfcn.h> 417c478bd9Sstevel@tonic-gate #include <errno.h> 427c478bd9Sstevel@tonic-gate #include <link.h> 435aefb655Srie #include <debug.h> 445aefb655Srie #include <conv.h> 457c478bd9Sstevel@tonic-gate #include "_rtld.h" 467c478bd9Sstevel@tonic-gate #include "_audit.h" 477c478bd9Sstevel@tonic-gate #include "_elf.h" 4856deab07SRod Evans #include "_a.out.h" 4956deab07SRod Evans #include "_inline.h" 507c478bd9Sstevel@tonic-gate #include "msg.h" 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate /* 537c478bd9Sstevel@tonic-gate * If a load filter flag is in effect, and this object is a filter, trigger the 547c478bd9Sstevel@tonic-gate * loading of all its filtees. The load filter flag is in effect when creating 557c478bd9Sstevel@tonic-gate * configuration files, or when under the control of ldd(1), or the LD_LOADFLTR 567c478bd9Sstevel@tonic-gate * environment variable is set, or this object was built with the -zloadfltr 577c478bd9Sstevel@tonic-gate * flag. Otherwise, filtee loading is deferred until triggered by a relocation. 587c478bd9Sstevel@tonic-gate */ 597c478bd9Sstevel@tonic-gate static void 609aa23310Srie load_filtees(Rt_map *lmp, int *in_nfavl) 617c478bd9Sstevel@tonic-gate { 627c478bd9Sstevel@tonic-gate if ((FLAGS1(lmp) & MSK_RT_FILTER) && 637c478bd9Sstevel@tonic-gate ((FLAGS(lmp) & FLG_RT_LOADFLTR) || 647c478bd9Sstevel@tonic-gate (LIST(lmp)->lm_tflags & LML_TFLG_LOADFLTR))) { 657c478bd9Sstevel@tonic-gate Dyninfo *dip = DYNINFO(lmp); 667c478bd9Sstevel@tonic-gate uint_t cnt, max = DYNINFOCNT(lmp); 677c478bd9Sstevel@tonic-gate Slookup sl; 687c478bd9Sstevel@tonic-gate 6975e7992aSrie /* 7075e7992aSrie * Initialize the symbol lookup data structure. 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++) { 757c478bd9Sstevel@tonic-gate if (((dip->di_flags & MSK_DI_FILTER) == 0) || 767c478bd9Sstevel@tonic-gate ((dip->di_flags & FLG_DI_AUXFLTR) && 777c478bd9Sstevel@tonic-gate (rtld_flags & RT_FL_NOAUXFLTR))) 787c478bd9Sstevel@tonic-gate continue; 799aa23310Srie (void) elf_lookup_filtee(&sl, 0, 0, cnt, in_nfavl); 807c478bd9Sstevel@tonic-gate } 817c478bd9Sstevel@tonic-gate } 827c478bd9Sstevel@tonic-gate } 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate /* 857c478bd9Sstevel@tonic-gate * Analyze one or more link-maps of a link map control list. This routine is 867c478bd9Sstevel@tonic-gate * called at startup to continue the processing of the main executable. It is 877c478bd9Sstevel@tonic-gate * also called each time a new set of objects are loaded, ie. from filters, 887c478bd9Sstevel@tonic-gate * lazy-loaded objects, or dlopen(). 897c478bd9Sstevel@tonic-gate * 907c478bd9Sstevel@tonic-gate * In each instance we traverse the link-map control list starting with the 917c478bd9Sstevel@tonic-gate * initial object. As dependencies are analyzed they are added to the link-map 927c478bd9Sstevel@tonic-gate * control list. Thus the list grows as we traverse it - this results in the 937c478bd9Sstevel@tonic-gate * breadth first ordering of all needed objects. 9456deab07SRod Evans * 9556deab07SRod Evans * Return the initial link-map from which analysis starts for relocate_lmc(). 967c478bd9Sstevel@tonic-gate */ 9756deab07SRod Evans Rt_map * 989aa23310Srie analyze_lmc(Lm_list *lml, Aliste nlmco, Rt_map *nlmp, int *in_nfavl) 997c478bd9Sstevel@tonic-gate { 10056deab07SRod Evans Rt_map *lmp; 1017c478bd9Sstevel@tonic-gate Lm_cntl *nlmc; 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate /* 1047c478bd9Sstevel@tonic-gate * If this link-map control list is being analyzed, return. The object 1057c478bd9Sstevel@tonic-gate * that has just been added will be picked up by the existing analysis 1067c478bd9Sstevel@tonic-gate * thread. Note, this is only really meaningful during process init- 1077c478bd9Sstevel@tonic-gate * ialization, as objects are added to the main link-map control list. 1087c478bd9Sstevel@tonic-gate * Following this initialization, each family of objects that are loaded 1097c478bd9Sstevel@tonic-gate * are added to a new link-map control list. 1107c478bd9Sstevel@tonic-gate */ 1117c478bd9Sstevel@tonic-gate /* LINTED */ 112cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 1137c478bd9Sstevel@tonic-gate if (nlmc->lc_flags & LMC_FLG_ANALYZING) 11456deab07SRod Evans return (nlmp); 1157c478bd9Sstevel@tonic-gate 1167c478bd9Sstevel@tonic-gate /* 1177c478bd9Sstevel@tonic-gate * If this object doesn't belong to the present link-map control list 1187c478bd9Sstevel@tonic-gate * then it must already have been analyzed, or it is in the process of 1197c478bd9Sstevel@tonic-gate * being analyzed prior to us recursing into this analysis. In either 1207c478bd9Sstevel@tonic-gate * case, ignore the object as it's already being taken care of. 1217c478bd9Sstevel@tonic-gate */ 1227c478bd9Sstevel@tonic-gate if (nlmco != CNTL(nlmp)) 12356deab07SRod Evans return (nlmp); 1247c478bd9Sstevel@tonic-gate 1257c478bd9Sstevel@tonic-gate nlmc->lc_flags |= LMC_FLG_ANALYZING; 1267c478bd9Sstevel@tonic-gate 12756deab07SRod Evans for (lmp = nlmp; lmp; lmp = NEXT_RT_MAP(lmp)) { 1287c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & 1297c478bd9Sstevel@tonic-gate (FLG_RT_ANALZING | FLG_RT_ANALYZED | FLG_RT_DELETE)) 1307c478bd9Sstevel@tonic-gate continue; 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate /* 1337c478bd9Sstevel@tonic-gate * Indicate that analyzing is under way. 1347c478bd9Sstevel@tonic-gate */ 1357c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_ANALZING; 1367c478bd9Sstevel@tonic-gate 1377c478bd9Sstevel@tonic-gate /* 1387c478bd9Sstevel@tonic-gate * If this link map represents a relocatable object, then we 1397c478bd9Sstevel@tonic-gate * need to finish the link-editing of the object at this point. 1407c478bd9Sstevel@tonic-gate */ 1417c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_OBJECT) { 14256deab07SRod Evans Rt_map *olmp; 14356deab07SRod Evans 14456deab07SRod Evans if ((olmp = elf_obj_fini(lml, lmp, in_nfavl)) == NULL) { 1457c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) 1467c478bd9Sstevel@tonic-gate continue; 14756deab07SRod Evans nlmp = NULL; 1487c478bd9Sstevel@tonic-gate break; 1497c478bd9Sstevel@tonic-gate } 15056deab07SRod Evans 15156deab07SRod Evans /* 15256deab07SRod Evans * The original link-map that captured a relocatable 15356deab07SRod Evans * object is a temporary link-map, that basically acts 15456deab07SRod Evans * as a place holder in the link-map list. On 15556deab07SRod Evans * completion of relocatable object processing, a new 15656deab07SRod Evans * link-map is created, and switched with the place 15756deab07SRod Evans * holder. Therefore, reassign both the present 15856deab07SRod Evans * link-map pointer and the return link-map pointer. 15956deab07SRod Evans * The former resets this routines link-map processing, 16056deab07SRod Evans * while the latter provides for later functions, like 16156deab07SRod Evans * relocate_lmc(), to start processing from this new 16256deab07SRod Evans * link-map. 16356deab07SRod Evans */ 16456deab07SRod Evans if (nlmp == lmp) 16556deab07SRod Evans nlmp = olmp; 16656deab07SRod Evans lmp = olmp; 1677c478bd9Sstevel@tonic-gate } 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate DBG_CALL(Dbg_file_analyze(lmp)); 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate /* 1727c478bd9Sstevel@tonic-gate * Establish any dependencies this object requires. 1737c478bd9Sstevel@tonic-gate */ 1749aa23310Srie if (LM_NEEDED(lmp)(lml, nlmco, lmp, in_nfavl) == 0) { 1757c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) 1767c478bd9Sstevel@tonic-gate continue; 17756deab07SRod Evans nlmp = NULL; 1787c478bd9Sstevel@tonic-gate break; 1797c478bd9Sstevel@tonic-gate } 1807c478bd9Sstevel@tonic-gate 1817c478bd9Sstevel@tonic-gate FLAGS(lmp) &= ~FLG_RT_ANALZING; 1827c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_ANALYZED; 1837c478bd9Sstevel@tonic-gate 1847c478bd9Sstevel@tonic-gate /* 1857c478bd9Sstevel@tonic-gate * If we're building a configuration file, determine if this 1867c478bd9Sstevel@tonic-gate * object is a filter and if so load its filtees. This 1877c478bd9Sstevel@tonic-gate * traversal is only necessary for crle(1), as typical use of 1887c478bd9Sstevel@tonic-gate * an object will load filters as part of relocation processing. 1897c478bd9Sstevel@tonic-gate */ 1907c478bd9Sstevel@tonic-gate if (MODE(nlmp) & RTLD_CONFGEN) 1919aa23310Srie load_filtees(lmp, in_nfavl); 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate /* 1947c478bd9Sstevel@tonic-gate * If an interposer has been added, it will have been inserted 1957c478bd9Sstevel@tonic-gate * in the link-map before the link we're presently analyzing. 1967c478bd9Sstevel@tonic-gate * Break out of this analysis loop and return to the head of 1977c478bd9Sstevel@tonic-gate * the link-map control list to analyze the interposer. Note 1987c478bd9Sstevel@tonic-gate * that this rescan preserves the breadth first loading of 1997c478bd9Sstevel@tonic-gate * dependencies. 2007c478bd9Sstevel@tonic-gate */ 20124a6229eSrie /* LINTED */ 202cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 2037c478bd9Sstevel@tonic-gate if (nlmc->lc_flags & LMC_FLG_REANALYZE) { 2047c478bd9Sstevel@tonic-gate nlmc->lc_flags &= ~LMC_FLG_REANALYZE; 2057c478bd9Sstevel@tonic-gate lmp = nlmc->lc_head; 2067c478bd9Sstevel@tonic-gate } 2077c478bd9Sstevel@tonic-gate } 2087c478bd9Sstevel@tonic-gate 20924a6229eSrie /* LINTED */ 210cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 2117c478bd9Sstevel@tonic-gate nlmc->lc_flags &= ~LMC_FLG_ANALYZING; 2127c478bd9Sstevel@tonic-gate 21356deab07SRod Evans return (nlmp); 2147c478bd9Sstevel@tonic-gate } 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate /* 217466e2a62Srie * Determine whether a symbol represents zero, .bss, bits. Most commonly this 218466e2a62Srie * function is used to determine whether the data for a copy relocation refers 219466e2a62Srie * to initialized data or .bss. If the data definition is within .bss, then the 220466e2a62Srie * data is zero filled, and as the copy destination within the executable is 221466e2a62Srie * .bss, we can skip copying zero's to zero's. 222466e2a62Srie * 223466e2a62Srie * However, if the defining object has MOVE data, it's .bss might contain 224466e2a62Srie * non-zero data, in which case copy the definition regardless. 225466e2a62Srie * 226466e2a62Srie * For backward compatibility copy relocation processing, this routine can be 227466e2a62Srie * used to determine precisely if a copy destination is a move record recipient. 2287c478bd9Sstevel@tonic-gate */ 2297c478bd9Sstevel@tonic-gate static int 230466e2a62Srie are_bits_zero(Rt_map *dlmp, Sym *dsym, int dest) 2317c478bd9Sstevel@tonic-gate { 23256deab07SRod Evans mmapobj_result_t *mpp; 2337c478bd9Sstevel@tonic-gate caddr_t daddr = (caddr_t)dsym->st_value; 2347c478bd9Sstevel@tonic-gate 2357c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & FLG_RT_FIXED) == 0) 2367c478bd9Sstevel@tonic-gate daddr += ADDR(dlmp); 2377c478bd9Sstevel@tonic-gate 238466e2a62Srie /* 239466e2a62Srie * Determine the segment that contains the copy definition. Given that 240466e2a62Srie * the copy relocation records have already been captured and verified, 241466e2a62Srie * a segment must be found (but we add an escape clause never the less). 242466e2a62Srie */ 24356deab07SRod Evans if ((mpp = find_segment(daddr, dlmp)) == NULL) 2447c478bd9Sstevel@tonic-gate return (1); 245466e2a62Srie 246466e2a62Srie /* 247466e2a62Srie * If the definition is not within .bss, indicate this is not zero data. 248466e2a62Srie */ 24956deab07SRod Evans if (daddr < (mpp->mr_addr + mpp->mr_offset + mpp->mr_fsize)) 2507c478bd9Sstevel@tonic-gate return (0); 251466e2a62Srie 252466e2a62Srie /* 253466e2a62Srie * If the definition is within .bss, make sure the definition isn't the 254466e2a62Srie * recipient of a move record. Note, we don't precisely analyze whether 255466e2a62Srie * the address is a move record recipient, as the infrastructure to 256466e2a62Srie * prepare for, and carry out this analysis, is probably more costly 257466e2a62Srie * than just copying the bytes regardless. 258466e2a62Srie */ 259466e2a62Srie if ((FLAGS(dlmp) & FLG_RT_MOVE) == 0) 260466e2a62Srie return (1); 261466e2a62Srie 262466e2a62Srie /* 263466e2a62Srie * However, for backward compatibility copy relocation processing, we 264466e2a62Srie * can afford to work a little harder. Here, determine precisely 265466e2a62Srie * whether the destination in the executable is a move record recipient. 266466e2a62Srie * See comments in lookup_sym_interpose(), below. 267466e2a62Srie */ 268466e2a62Srie if (dest && is_move_data(daddr)) 269466e2a62Srie return (0); 270466e2a62Srie 271466e2a62Srie return (1); 2727c478bd9Sstevel@tonic-gate } 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate /* 2757c478bd9Sstevel@tonic-gate * Relocate an individual object. 2767c478bd9Sstevel@tonic-gate */ 2777c478bd9Sstevel@tonic-gate static int 2789aa23310Srie relocate_so(Lm_list *lml, Rt_map *lmp, int *relocated, int now, int *in_nfavl) 2797c478bd9Sstevel@tonic-gate { 28056deab07SRod Evans APlist *textrel = NULL; 28156deab07SRod Evans int ret = 1; 28256deab07SRod Evans 2837c478bd9Sstevel@tonic-gate /* 2847c478bd9Sstevel@tonic-gate * If we're running under ldd(1), and haven't been asked to trace any 2857c478bd9Sstevel@tonic-gate * warnings, skip any actual relocation processing. 2867c478bd9Sstevel@tonic-gate */ 2877c478bd9Sstevel@tonic-gate if (((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0) || 2887c478bd9Sstevel@tonic-gate (lml->lm_flags & LML_FLG_TRC_WARN)) { 2897c478bd9Sstevel@tonic-gate 2907c478bd9Sstevel@tonic-gate if (relocated) 2917c478bd9Sstevel@tonic-gate (*relocated)++; 2927c478bd9Sstevel@tonic-gate 29356deab07SRod Evans if ((LM_RELOC(lmp)(lmp, now, in_nfavl, &textrel) == 0) && 2947c478bd9Sstevel@tonic-gate ((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0)) 29556deab07SRod Evans ret = 0; 29656deab07SRod Evans 29756deab07SRod Evans /* 29856deab07SRod Evans * Finally process any move data. Note, this is carried out 29956deab07SRod Evans * with ldd(1) under relocation processing too, as it can flush 30056deab07SRod Evans * out move errors, and enables lari(1) to provide a true 30156deab07SRod Evans * representation of the runtime bindings. 30256deab07SRod Evans */ 30356deab07SRod Evans if ((FLAGS(lmp) & FLG_RT_MOVE) && 30456deab07SRod Evans (move_data(lmp, &textrel) == 0) && 30556deab07SRod Evans ((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0)) 30656deab07SRod Evans ret = 0; 3077c478bd9Sstevel@tonic-gate } 30856deab07SRod Evans 30956deab07SRod Evans /* 31056deab07SRod Evans * If a text segment was write enabled to perform any relocations or 31156deab07SRod Evans * move records, then re-protect the segment by disabling writes. 31256deab07SRod Evans */ 31356deab07SRod Evans if (textrel) { 31456deab07SRod Evans mmapobj_result_t *mpp; 31556deab07SRod Evans Aliste idx; 31656deab07SRod Evans 31756deab07SRod Evans for (APLIST_TRAVERSE(textrel, idx, mpp)) 31856deab07SRod Evans (void) set_prot(lmp, mpp, 0); 31956deab07SRod Evans free(textrel); 32056deab07SRod Evans } 32156deab07SRod Evans 32256deab07SRod Evans return (ret); 3237c478bd9Sstevel@tonic-gate } 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate /* 3267c478bd9Sstevel@tonic-gate * Relocate the objects on a link-map control list. 3277c478bd9Sstevel@tonic-gate */ 3287c478bd9Sstevel@tonic-gate static int 32956deab07SRod Evans _relocate_lmc(Lm_list *lml, Aliste lmco, Rt_map *nlmp, int *relocated, 33056deab07SRod Evans int *in_nfavl) 3317c478bd9Sstevel@tonic-gate { 3327c478bd9Sstevel@tonic-gate Rt_map *lmp; 3337c478bd9Sstevel@tonic-gate 334cb511613SAli Bahrami for (lmp = nlmp; lmp; lmp = NEXT_RT_MAP(lmp)) { 3357c478bd9Sstevel@tonic-gate /* 3367c478bd9Sstevel@tonic-gate * If this object has already been relocated, we're done. If 3377c478bd9Sstevel@tonic-gate * this object is being deleted, skip it, there's probably a 3387c478bd9Sstevel@tonic-gate * relocation error somewhere that's causing this deletion. 3397c478bd9Sstevel@tonic-gate */ 3407c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & 3417c478bd9Sstevel@tonic-gate (FLG_RT_RELOCING | FLG_RT_RELOCED | FLG_RT_DELETE)) 3427c478bd9Sstevel@tonic-gate continue; 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate /* 3457c478bd9Sstevel@tonic-gate * Indicate that relocation processing is under way. 3467c478bd9Sstevel@tonic-gate */ 3477c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_RELOCING; 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate /* 3507c478bd9Sstevel@tonic-gate * Relocate the object. 3517c478bd9Sstevel@tonic-gate */ 3529aa23310Srie if (relocate_so(lml, lmp, relocated, 0, in_nfavl) == 0) 3537c478bd9Sstevel@tonic-gate return (0); 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate /* 3567c478bd9Sstevel@tonic-gate * Indicate that the objects relocation is complete. 3577c478bd9Sstevel@tonic-gate */ 3587c478bd9Sstevel@tonic-gate FLAGS(lmp) &= ~FLG_RT_RELOCING; 3597c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_RELOCED; 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate /* 36256deab07SRod Evans * If this object is being relocated on the main link-map list 36356deab07SRod Evans * indicate that this object's init is available for harvesting. 36456deab07SRod Evans * Objects that are being collected on other link-map lists 36556deab07SRod Evans * will have there init availability tagged when the objects 36656deab07SRod Evans * are move to the main link-map list (ie, after we know they, 36756deab07SRod Evans * and their dependencies, are fully relocated and ready for 36856deab07SRod Evans * use). 36956deab07SRod Evans * 37056deab07SRod Evans * Note, even under ldd(1) this init identification is necessary 37156deab07SRod Evans * for -i (tsort) gathering. 3727c478bd9Sstevel@tonic-gate */ 37356deab07SRod Evans if (lmco == ALIST_OFF_DATA) { 3747c478bd9Sstevel@tonic-gate lml->lm_init++; 375dffec89cSrie lml->lm_flags |= LML_FLG_OBJADDED; 376466e2a62Srie } 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate /* 3797c478bd9Sstevel@tonic-gate * Determine if this object is a filter, and if a load filter 3807c478bd9Sstevel@tonic-gate * flag is in effect, trigger the loading of all its filtees. 3817c478bd9Sstevel@tonic-gate */ 3829aa23310Srie load_filtees(lmp, in_nfavl); 3837c478bd9Sstevel@tonic-gate } 3847c478bd9Sstevel@tonic-gate 3857c478bd9Sstevel@tonic-gate /* 3867c478bd9Sstevel@tonic-gate * Perform special copy relocations. These are only meaningful for 3877c478bd9Sstevel@tonic-gate * dynamic executables (fixed and head of their link-map list). If 3887c478bd9Sstevel@tonic-gate * this ever has to change then the infrastructure of COPY() has to 389cce0e03bSab196087 * change. Presently, a given link map can only have a receiver or 390cce0e03bSab196087 * supplier of copy data, so a union is used to overlap the storage 391cce0e03bSab196087 * for the COPY_R() and COPY_S() lists. These lists would need to 392cce0e03bSab196087 * be separated. 3937c478bd9Sstevel@tonic-gate */ 3947c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) & FLG_RT_FIXED) && (nlmp == LIST(nlmp)->lm_head) && 3957c478bd9Sstevel@tonic-gate (((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0) || 3967c478bd9Sstevel@tonic-gate (lml->lm_flags & LML_FLG_TRC_WARN))) { 397cce0e03bSab196087 Rt_map *lmp; 398cce0e03bSab196087 Aliste idx1; 3997c478bd9Sstevel@tonic-gate Word tracing; 4007c478bd9Sstevel@tonic-gate 40102ca3e02Srie #if defined(__i386) 4027c478bd9Sstevel@tonic-gate if (elf_copy_gen(nlmp) == 0) 4037c478bd9Sstevel@tonic-gate return (0); 4047c478bd9Sstevel@tonic-gate #endif 405cce0e03bSab196087 if (COPY_S(nlmp) == NULL) 4067c478bd9Sstevel@tonic-gate return (1); 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate if ((LIST(nlmp)->lm_flags & LML_FLG_TRC_ENABLE) && 4097c478bd9Sstevel@tonic-gate (((rtld_flags & RT_FL_SILENCERR) == 0) || 4107c478bd9Sstevel@tonic-gate (LIST(nlmp)->lm_flags & LML_FLG_TRC_VERBOSE))) 4117c478bd9Sstevel@tonic-gate tracing = 1; 4127c478bd9Sstevel@tonic-gate else 4137c478bd9Sstevel@tonic-gate tracing = 0; 4147c478bd9Sstevel@tonic-gate 4155aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 4167c478bd9Sstevel@tonic-gate 417cce0e03bSab196087 for (APLIST_TRAVERSE(COPY_S(nlmp), idx1, lmp)) { 4187c478bd9Sstevel@tonic-gate Rel_copy *rcp; 419cce0e03bSab196087 Aliste idx2; 4207c478bd9Sstevel@tonic-gate 421cce0e03bSab196087 for (ALIST_TRAVERSE(COPY_R(lmp), idx2, rcp)) { 4227c478bd9Sstevel@tonic-gate int zero; 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate /* 425466e2a62Srie * Only copy the data if the data is from 426466e2a62Srie * a non-zero definition (ie. not .bss). 4277c478bd9Sstevel@tonic-gate */ 428466e2a62Srie zero = are_bits_zero(rcp->r_dlmp, 429466e2a62Srie rcp->r_dsym, 0); 4305aefb655Srie DBG_CALL(Dbg_reloc_copy(rcp->r_dlmp, nlmp, 4315aefb655Srie rcp->r_name, zero)); 4327c478bd9Sstevel@tonic-gate if (zero) 4337c478bd9Sstevel@tonic-gate continue; 4347c478bd9Sstevel@tonic-gate 4357c478bd9Sstevel@tonic-gate (void) memcpy(rcp->r_radd, rcp->r_dadd, 4367c478bd9Sstevel@tonic-gate rcp->r_size); 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate if ((tracing == 0) || ((FLAGS1(rcp->r_dlmp) & 4397c478bd9Sstevel@tonic-gate FL1_RT_DISPREL) == 0)) 4407c478bd9Sstevel@tonic-gate continue; 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_REL_CPYDISP), 4437c478bd9Sstevel@tonic-gate demangle(rcp->r_name), NAME(rcp->r_dlmp)); 4447c478bd9Sstevel@tonic-gate } 4457c478bd9Sstevel@tonic-gate } 4467c478bd9Sstevel@tonic-gate 4475aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 4487c478bd9Sstevel@tonic-gate 449cce0e03bSab196087 free(COPY_S(nlmp)); 4502017c965SRod Evans COPY_S(nlmp) = NULL; 4517c478bd9Sstevel@tonic-gate } 4527c478bd9Sstevel@tonic-gate return (1); 4537c478bd9Sstevel@tonic-gate } 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate int 4569aa23310Srie relocate_lmc(Lm_list *lml, Aliste nlmco, Rt_map *clmp, Rt_map *nlmp, 4579aa23310Srie int *in_nfavl) 4587c478bd9Sstevel@tonic-gate { 4597c478bd9Sstevel@tonic-gate int lret = 1, pret = 1; 460cce0e03bSab196087 APlist *alp; 4617c478bd9Sstevel@tonic-gate Aliste plmco; 4627c478bd9Sstevel@tonic-gate Lm_cntl *plmc, *nlmc; 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate /* 4657c478bd9Sstevel@tonic-gate * If this link-map control list is being relocated, return. The object 4667c478bd9Sstevel@tonic-gate * that has just been added will be picked up by the existing relocation 4677c478bd9Sstevel@tonic-gate * thread. Note, this is only really meaningful during process init- 4687c478bd9Sstevel@tonic-gate * ialization, as objects are added to the main link-map control list. 4697c478bd9Sstevel@tonic-gate * Following this initialization, each family of objects that are loaded 4707c478bd9Sstevel@tonic-gate * are added to a new link-map control list. 4717c478bd9Sstevel@tonic-gate */ 4727c478bd9Sstevel@tonic-gate /* LINTED */ 473cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 4747c478bd9Sstevel@tonic-gate 4757c478bd9Sstevel@tonic-gate if (nlmc->lc_flags & LMC_FLG_RELOCATING) 4767c478bd9Sstevel@tonic-gate return (1); 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate nlmc->lc_flags |= LMC_FLG_RELOCATING; 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate /* 4817c478bd9Sstevel@tonic-gate * Relocate one or more link-maps of a link map control list. If this 4827c478bd9Sstevel@tonic-gate * object doesn't belong to the present link-map control list then it 4837c478bd9Sstevel@tonic-gate * must already have been relocated, or it is in the process of being 4847c478bd9Sstevel@tonic-gate * relocated prior to us recursing into this relocation. In either 4857c478bd9Sstevel@tonic-gate * case, ignore the object as it's already being taken care of, however, 4867c478bd9Sstevel@tonic-gate * fall through and capture any relocation promotions that might have 4877c478bd9Sstevel@tonic-gate * been established from the reference mode of this object. 4887c478bd9Sstevel@tonic-gate * 4897c478bd9Sstevel@tonic-gate * If we're generating a configuration file using crle(1), two passes 4907c478bd9Sstevel@tonic-gate * may be involved. Under the first pass, RTLD_CONFGEN is set. Under 4917c478bd9Sstevel@tonic-gate * this pass, crle() loads objects into the process address space. No 4927c478bd9Sstevel@tonic-gate * relocation is necessary at this point, we simply need to analyze the 4937c478bd9Sstevel@tonic-gate * objects to insure any directly bound dependencies, filtees, etc. 4947c478bd9Sstevel@tonic-gate * get loaded. Although we skip the relocation, fall through to insure 4957c478bd9Sstevel@tonic-gate * any control lists are maintained appropriately. 4967c478bd9Sstevel@tonic-gate * 4977c478bd9Sstevel@tonic-gate * If objects are to be dldump(3c)'ed, crle(1) makes a second pass, 4987c478bd9Sstevel@tonic-gate * using RTLD_NOW and RTLD_CONFGEN. The RTLD_NOW effectively carries 4997c478bd9Sstevel@tonic-gate * out the relocations of all loaded objects. 5007c478bd9Sstevel@tonic-gate */ 5017c478bd9Sstevel@tonic-gate if ((nlmco == CNTL(nlmp)) && 5027c478bd9Sstevel@tonic-gate ((MODE(nlmp) & (RTLD_NOW | RTLD_CONFGEN)) != RTLD_CONFGEN)) { 5037c478bd9Sstevel@tonic-gate int relocated = 0; 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate /* 5067c478bd9Sstevel@tonic-gate * Determine whether the initial link-map control list has 5077c478bd9Sstevel@tonic-gate * started relocation. From this point, should any interposing 5087c478bd9Sstevel@tonic-gate * objects be added to this link-map control list, the objects 5097c478bd9Sstevel@tonic-gate * are demoted to standard objects. Their interposition can't 5107c478bd9Sstevel@tonic-gate * be guaranteed once relocations have been carried out. 5117c478bd9Sstevel@tonic-gate */ 512cce0e03bSab196087 if (nlmco == ALIST_OFF_DATA) 5137c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_STARTREL; 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate /* 51602ca3e02Srie * Relocate the link-map control list. Should this relocation 51702ca3e02Srie * fail, clean up this link-map list. Relocations within this 51802ca3e02Srie * list may have required relocation promotions on other lists, 51902ca3e02Srie * so before acting upon these, and possibly adding more objects 52002ca3e02Srie * to the present link-map control list, try and clean up any 52102ca3e02Srie * failed objects now. 5227c478bd9Sstevel@tonic-gate */ 52356deab07SRod Evans lret = _relocate_lmc(lml, nlmco, nlmp, &relocated, in_nfavl); 524cce0e03bSab196087 if ((lret == 0) && (nlmco != ALIST_OFF_DATA)) 525481bba9eSRod Evans remove_lmc(lml, clmp, nlmco, NAME(nlmp)); 5267c478bd9Sstevel@tonic-gate } 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate /* 5297c478bd9Sstevel@tonic-gate * Determine the new, and previous link-map control lists. 5307c478bd9Sstevel@tonic-gate */ 53124a6229eSrie /* LINTED */ 532cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 533cce0e03bSab196087 if (nlmco == ALIST_OFF_DATA) { 5346679fdc0Srie plmco = nlmco; 5357c478bd9Sstevel@tonic-gate plmc = nlmc; 5366679fdc0Srie } else { 5377c478bd9Sstevel@tonic-gate plmco = nlmco - lml->lm_lists->al_size; 5387c478bd9Sstevel@tonic-gate /* LINTED */ 539cce0e03bSab196087 plmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, plmco); 5407c478bd9Sstevel@tonic-gate } 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate /* 5437c478bd9Sstevel@tonic-gate * Having completed this control list of objects, they can now be bound 5447c478bd9Sstevel@tonic-gate * to from other objects. Move this control list to the control list 5457c478bd9Sstevel@tonic-gate * that precedes it. Although this control list may have only bound to 5467c478bd9Sstevel@tonic-gate * controls lists much higher up the control list stack, it must only 5477c478bd9Sstevel@tonic-gate * be moved up one control list so as to preserve the link-map order 5487c478bd9Sstevel@tonic-gate * that may have already been traversed in search of symbols. 5497c478bd9Sstevel@tonic-gate */ 550cce0e03bSab196087 if (lret && (nlmco != ALIST_OFF_DATA) && nlmc->lc_head) 5517c478bd9Sstevel@tonic-gate lm_move(lml, nlmco, plmco, nlmc, plmc); 5527c478bd9Sstevel@tonic-gate 5537c478bd9Sstevel@tonic-gate /* 5547c478bd9Sstevel@tonic-gate * Determine whether existing objects that have already been relocated, 5557c478bd9Sstevel@tonic-gate * need any additional relocations performed. This can occur when new 5567c478bd9Sstevel@tonic-gate * objects are loaded with RTLD_NOW, and these new objects have 5577c478bd9Sstevel@tonic-gate * dependencies on objects that are already loaded. Note, that we peel 5587c478bd9Sstevel@tonic-gate * any relocation promotions off of one control list at a time. This 5597c478bd9Sstevel@tonic-gate * prevents relocations from being bound to objects that might yet fail 5607c478bd9Sstevel@tonic-gate * to relocate themselves. 5617c478bd9Sstevel@tonic-gate */ 562cce0e03bSab196087 while ((alp = plmc->lc_now) != NULL) { 563cce0e03bSab196087 Aliste idx; 564cce0e03bSab196087 Rt_map *lmp; 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate /* 5677c478bd9Sstevel@tonic-gate * Remove the relocation promotion list, as performing more 5687c478bd9Sstevel@tonic-gate * relocations may result in discovering more objects that need 5697c478bd9Sstevel@tonic-gate * promotion. 5707c478bd9Sstevel@tonic-gate */ 571cce0e03bSab196087 plmc->lc_now = NULL; 5727c478bd9Sstevel@tonic-gate 573cce0e03bSab196087 for (APLIST_TRAVERSE(alp, idx, lmp)) { 5747c478bd9Sstevel@tonic-gate /* 5757c478bd9Sstevel@tonic-gate * If the original relocation of the link-map control 5767c478bd9Sstevel@tonic-gate * list failed, or one of the relocation promotions of 5777c478bd9Sstevel@tonic-gate * this loop has failed, demote any pending objects 5787c478bd9Sstevel@tonic-gate * relocation mode. 5797c478bd9Sstevel@tonic-gate */ 5807c478bd9Sstevel@tonic-gate if ((lret == 0) || (pret == 0)) { 5817c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_NOW; 5827c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_LAZY; 5837c478bd9Sstevel@tonic-gate continue; 5847c478bd9Sstevel@tonic-gate } 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate /* 5877c478bd9Sstevel@tonic-gate * If a relocation fails, save the error condition. 5887c478bd9Sstevel@tonic-gate * It's possible that all new objects on the original 5897c478bd9Sstevel@tonic-gate * link-map control list have been relocated 5907c478bd9Sstevel@tonic-gate * successfully, but if the user request requires 5917c478bd9Sstevel@tonic-gate * promoting objects that have already been loaded, we 5927c478bd9Sstevel@tonic-gate * have to indicate that this operation couldn't be 5937c478bd9Sstevel@tonic-gate * performed. The unrelocated objects are in use on 5947c478bd9Sstevel@tonic-gate * another control list, and may continue to be used. 5957c478bd9Sstevel@tonic-gate * If the .plt that resulted in the error is called, 5967c478bd9Sstevel@tonic-gate * then the process will receive a fatal error at that 5977c478bd9Sstevel@tonic-gate * time. But, the .plt may never be called. 5987c478bd9Sstevel@tonic-gate */ 5999aa23310Srie if (relocate_so(lml, lmp, 0, 1, in_nfavl) == 0) 6007c478bd9Sstevel@tonic-gate pret = 0; 6017c478bd9Sstevel@tonic-gate } 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate /* 6047c478bd9Sstevel@tonic-gate * Having promoted any objects, determine whether additional 6057c478bd9Sstevel@tonic-gate * dependencies were added, and if so move them to the previous 6067c478bd9Sstevel@tonic-gate * link-map control list. 6077c478bd9Sstevel@tonic-gate */ 60824a6229eSrie /* LINTED */ 609cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 61024a6229eSrie /* LINTED */ 611cce0e03bSab196087 plmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, plmco); 612cce0e03bSab196087 if ((nlmco != ALIST_OFF_DATA) && nlmc->lc_head) 6137c478bd9Sstevel@tonic-gate lm_move(lml, nlmco, plmco, nlmc, plmc); 6148521e5e6Srie free(alp); 6157c478bd9Sstevel@tonic-gate } 6167c478bd9Sstevel@tonic-gate 61724a6229eSrie /* 61802ca3e02Srie * If relocations have been successful, indicate that relocations are 61902ca3e02Srie * no longer active for this control list. Otherwise, leave the 62002ca3e02Srie * relocation flag, as this flag is used to determine the style of 62102ca3e02Srie * cleanup (see remove_lmc()). 62224a6229eSrie */ 62302ca3e02Srie if (lret && pret) { 62424a6229eSrie /* LINTED */ 625cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 6267c478bd9Sstevel@tonic-gate nlmc->lc_flags &= ~LMC_FLG_RELOCATING; 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate return (1); 62902ca3e02Srie } 63002ca3e02Srie 6317c478bd9Sstevel@tonic-gate return (0); 6327c478bd9Sstevel@tonic-gate } 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate /* 6357c478bd9Sstevel@tonic-gate * Inherit the first rejection message for possible later diagnostics. 6367c478bd9Sstevel@tonic-gate * 6377c478bd9Sstevel@tonic-gate * Any attempt to process a file that is unsuccessful, should be accompanied 6387c478bd9Sstevel@tonic-gate * with an error diagnostic. However, some operations like searching for a 6397c478bd9Sstevel@tonic-gate * simple filename, involve trying numerous paths, and an error message for each 6407c478bd9Sstevel@tonic-gate * lookup is not required. Although a multiple search can fail, it's possible 6417c478bd9Sstevel@tonic-gate * that a file was found, but was rejected because it was the wrong type. 6427c478bd9Sstevel@tonic-gate * To satisfy these possibilities, the first failure is recorded as a rejection 6437c478bd9Sstevel@tonic-gate * message, and this message is used later for a more specific diagnostic. 6447c478bd9Sstevel@tonic-gate * 6457c478bd9Sstevel@tonic-gate * File searches are focused at load_one(), and from here a rejection descriptor 6467c478bd9Sstevel@tonic-gate * is passed down to various child routines. If these child routines can 6477c478bd9Sstevel@tonic-gate * process multiple files, then they will maintain their own rejection desc- 6487c478bd9Sstevel@tonic-gate * riptor. This is filled in for any failures, and a diagnostic produced to 6497c478bd9Sstevel@tonic-gate * reflect the failure. The child routines then employ rejection_inherit() to 6507c478bd9Sstevel@tonic-gate * pass the first rejection message back to load_one(). 6517c478bd9Sstevel@tonic-gate * 6527c478bd9Sstevel@tonic-gate * Note that the name, and rejection string must be duplicated, as the name 6537c478bd9Sstevel@tonic-gate * buffer and error string buffer (see conv_ routines) may be reused for 6547c478bd9Sstevel@tonic-gate * additional processing or rejection messages. 6557c478bd9Sstevel@tonic-gate */ 6567c478bd9Sstevel@tonic-gate void 65731fdd7caSab196087 rejection_inherit(Rej_desc *rej1, Rej_desc *rej2) 6587c478bd9Sstevel@tonic-gate { 6597c478bd9Sstevel@tonic-gate if (rej2->rej_type && (rej1->rej_type == 0)) { 6607c478bd9Sstevel@tonic-gate rej1->rej_type = rej2->rej_type; 6617c478bd9Sstevel@tonic-gate rej1->rej_info = rej2->rej_info; 66256deab07SRod Evans rej1->rej_flags = rej2->rej_flags; 6637c478bd9Sstevel@tonic-gate if (rej2->rej_name) 66456deab07SRod Evans rej1->rej_name = stravl_insert(rej2->rej_name, 0, 0, 0); 66556deab07SRod Evans if ((rej2->rej_str) && ((rej1->rej_str = 66656deab07SRod Evans stravl_insert(rej2->rej_str, 0, 0, 0)) == NULL)) 6677c478bd9Sstevel@tonic-gate rej1->rej_str = MSG_ORIG(MSG_EMG_ENOMEM); 6687c478bd9Sstevel@tonic-gate } 6697c478bd9Sstevel@tonic-gate } 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate /* 6720aa3cd4dSrie * Helper routine for is_so_matched() that consolidates matching a path name, 6730aa3cd4dSrie * or file name component of a link-map name. 6747c478bd9Sstevel@tonic-gate */ 67556deab07SRod Evans inline static int 6760aa3cd4dSrie _is_so_matched(const char *name, const char *str, int path) 6777c478bd9Sstevel@tonic-gate { 6787c478bd9Sstevel@tonic-gate const char *_str; 6797c478bd9Sstevel@tonic-gate 6800aa3cd4dSrie if ((path == 0) && ((_str = strrchr(str, '/')) != NULL)) 6817c478bd9Sstevel@tonic-gate _str++; 6827c478bd9Sstevel@tonic-gate else 6837c478bd9Sstevel@tonic-gate _str = str; 6847c478bd9Sstevel@tonic-gate 6857c478bd9Sstevel@tonic-gate return (strcmp(name, _str)); 6867c478bd9Sstevel@tonic-gate } 6877c478bd9Sstevel@tonic-gate 6880aa3cd4dSrie /* 6890aa3cd4dSrie * Determine whether a search name matches one of the names associated with a 6900aa3cd4dSrie * link-map. A link-map contains several names: 6910aa3cd4dSrie * 6922017c965SRod Evans * - a NAME() - this is the basename of the dynamic executable that started 6932017c965SRod Evans * the process, and the path name of any dependencies used by the process. 6942017c965SRod Evans * Most executables are received as full path names, as exec() prepends a 6952017c965SRod Evans * search $PATH to locate the executable. However, simple file names can 6962017c965SRod Evans * be received from exec() if the file is executed from the present working 6972017c965SRod Evans * directory. Regardless, ld.so.1 maintains NAME() as the basename, as 6982017c965SRod Evans * this has always been the name used in diagnostics and error messages. 6992017c965SRod Evans * Most dependencies are full path names, as the typical search for a 7002017c965SRod Evans * dependency, say "libx.so.1", results in search paths being prepended to 7012017c965SRod Evans * the name, which eventually open "/lib/libx.so.1". However, relative 7022017c965SRod Evans * path names can be supplied as dependencies, e.g. dlopen("../libx.so.1"). 7030aa3cd4dSrie * 7042017c965SRod Evans * - a PATHNAME() - this is the fully resolved path name of the object. This 7052017c965SRod Evans * name will differ from NAME() for all dynamic executables, and may differ 7062017c965SRod Evans * from the NAME() of dependencies, if the dependency is not a full path 7072017c965SRod Evans * name, or the dependency resolves to a symbolic link. 7080aa3cd4dSrie * 7092017c965SRod Evans * - an ALIAS() name - these are alternative names by which the object has 71056deab07SRod Evans * been found, ie. when dependencies are loaded through a variety of 71156deab07SRod Evans * different symbolic links. 7120aa3cd4dSrie * 7130aa3cd4dSrie * The name pattern matching can differ depending on whether we are looking 7140aa3cd4dSrie * for a full path name (path != 0), or a simple file name (path == 0). Full 71556deab07SRod Evans * path names typically match NAME() or PATHNAME() entries. 7160aa3cd4dSrie * 7170aa3cd4dSrie * For all full path name searches, the link-map names are taken as is. For 7180aa3cd4dSrie * simple file name searches, only the file name component of any link-map 7190aa3cd4dSrie * names are used for comparison. 7200aa3cd4dSrie */ 72156deab07SRod Evans inline static Rt_map * 7220aa3cd4dSrie is_so_matched(Rt_map *lmp, const char *name, int path) 7237c478bd9Sstevel@tonic-gate { 724cce0e03bSab196087 Aliste idx; 725cce0e03bSab196087 const char *cp; 7267c478bd9Sstevel@tonic-gate 72756deab07SRod Evans if (_is_so_matched(name, NAME(lmp), path) == 0) 7287c478bd9Sstevel@tonic-gate return (lmp); 7297c478bd9Sstevel@tonic-gate 7307c478bd9Sstevel@tonic-gate if (PATHNAME(lmp) != NAME(lmp)) { 73156deab07SRod Evans if (_is_so_matched(name, PATHNAME(lmp), path) == 0) 7327c478bd9Sstevel@tonic-gate return (lmp); 7337c478bd9Sstevel@tonic-gate } 7340aa3cd4dSrie 735cce0e03bSab196087 for (APLIST_TRAVERSE(ALIAS(lmp), idx, cp)) { 736cce0e03bSab196087 if (_is_so_matched(name, cp, path) == 0) 7370aa3cd4dSrie return (lmp); 7380aa3cd4dSrie } 7390aa3cd4dSrie 74037ffaf83SRod Evans return (NULL); 7417c478bd9Sstevel@tonic-gate } 7427c478bd9Sstevel@tonic-gate 7430aa3cd4dSrie /* 7440aa3cd4dSrie * Files are opened by ld.so.1 to satisfy dependencies, filtees and dlopen() 7450aa3cd4dSrie * requests. Each request investigates the file based upon the callers 7469aa23310Srie * environment. Once a full path name has been established, the following 7479aa23310Srie * checks are made: 7480aa3cd4dSrie * 7492017c965SRod Evans * - does the path exist in the link-map lists FullPathNode AVL tree? if 7509aa23310Srie * so, the file is already loaded, and its associated link-map pointer 7519aa23310Srie * is returned. 7522017c965SRod Evans * - does the path exist in the not-found AVL tree? if so, this path has 7539aa23310Srie * already been determined to not exist, and a failure is returned. 7542017c965SRod Evans * - a device/inode check, to ensure the same file isn't mapped multiple 7559aa23310Srie * times through different paths. See file_open(). 7569aa23310Srie * 7579aa23310Srie * However, there are cases where a test for an existing file name needs to be 7589aa23310Srie * carried out, such as dlopen(NOLOAD) requests, dldump() requests, and as a 7599aa23310Srie * final fallback to dependency loading. These requests are handled by 7609aa23310Srie * is_so_loaded(). 7610aa3cd4dSrie * 7620aa3cd4dSrie * A traversal through the callers link-map list is carried out, and from each 7630aa3cd4dSrie * link-map, a comparison is made against all of the various names by which the 7649aa23310Srie * object has been referenced. is_so_matched() is used to compares the link-map 7659aa23310Srie * names against the name being searched for. Whether the search name is a full 7669aa23310Srie * path name or a simple file name, governs what comparisons are made. 7670aa3cd4dSrie * 7680aa3cd4dSrie * A full path name, which is a fully resolved path name that starts with a "/" 7690aa3cd4dSrie * character, or a relative path name that includes a "/" character, must match 77056deab07SRod Evans * the link-map names exactly. A simple file name, which is any name *not* 7710aa3cd4dSrie * containing a "/" character, are matched against the file name component of 7720aa3cd4dSrie * any link-map names. 7730aa3cd4dSrie */ 7747c478bd9Sstevel@tonic-gate Rt_map * 7759aa23310Srie is_so_loaded(Lm_list *lml, const char *name, int *in_nfavl) 7767c478bd9Sstevel@tonic-gate { 7777c478bd9Sstevel@tonic-gate Rt_map *lmp; 7787c478bd9Sstevel@tonic-gate avl_index_t where; 7797c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 780cce0e03bSab196087 Aliste idx; 7810aa3cd4dSrie int path = 0; 7827c478bd9Sstevel@tonic-gate 7837c478bd9Sstevel@tonic-gate /* 7840aa3cd4dSrie * If the name is a full path name, first determine if the path name is 7859aa23310Srie * registered on the FullPathNode AVL, or not-found AVL trees. 7867c478bd9Sstevel@tonic-gate */ 7879aa23310Srie if (name[0] == '/') { 78856deab07SRod Evans uint_t hash = sgs_str_hash(name); 78956deab07SRod Evans 79056deab07SRod Evans if (((lmp = fpavl_recorded(lml, name, hash, &where)) != NULL) && 7917c478bd9Sstevel@tonic-gate ((FLAGS(lmp) & (FLG_RT_OBJECT | FLG_RT_DELETE)) == 0)) 7927c478bd9Sstevel@tonic-gate return (lmp); 79356deab07SRod Evans 79456deab07SRod Evans if (nfavl_recorded(name, hash, 0)) { 7959aa23310Srie /* 7969aa23310Srie * For dlopen() and dlsym() fall backs, indicate that 7979aa23310Srie * a registered not-found path has indicated that this 7989aa23310Srie * object does not exist. 7999aa23310Srie */ 8009aa23310Srie if (in_nfavl) 8019aa23310Srie (*in_nfavl)++; 80237ffaf83SRod Evans return (NULL); 8039aa23310Srie } 8049aa23310Srie } 8057c478bd9Sstevel@tonic-gate 8067c478bd9Sstevel@tonic-gate /* 8070aa3cd4dSrie * Determine whether the name is a simple file name, or a path name. 8087c478bd9Sstevel@tonic-gate */ 8090aa3cd4dSrie if (strchr(name, '/')) 8100aa3cd4dSrie path++; 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate /* 8137c478bd9Sstevel@tonic-gate * Loop through the callers link-map lists. 8147c478bd9Sstevel@tonic-gate */ 815cce0e03bSab196087 for (ALIST_TRAVERSE(lml->lm_lists, idx, lmc)) { 816cb511613SAli Bahrami for (lmp = lmc->lc_head; lmp; lmp = NEXT_RT_MAP(lmp)) { 8177c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & (FLG_RT_OBJECT | FLG_RT_DELETE)) 8187c478bd9Sstevel@tonic-gate continue; 8197c478bd9Sstevel@tonic-gate 8200aa3cd4dSrie if (is_so_matched(lmp, name, path)) 8217c478bd9Sstevel@tonic-gate return (lmp); 8227c478bd9Sstevel@tonic-gate } 8237c478bd9Sstevel@tonic-gate } 82437ffaf83SRod Evans return (NULL); 8257c478bd9Sstevel@tonic-gate } 8267c478bd9Sstevel@tonic-gate 8277c478bd9Sstevel@tonic-gate /* 8287c478bd9Sstevel@tonic-gate * Tracing is enabled by the LD_TRACE_LOADED_OPTIONS environment variable which 8297c478bd9Sstevel@tonic-gate * is normally set from ldd(1). For each link map we load, print the load name 8307c478bd9Sstevel@tonic-gate * and the full pathname of the shared object. 8317c478bd9Sstevel@tonic-gate */ 8327c478bd9Sstevel@tonic-gate /* ARGSUSED4 */ 8337c478bd9Sstevel@tonic-gate static void 8347c478bd9Sstevel@tonic-gate trace_so(Rt_map *clmp, Rej_desc *rej, const char *name, const char *path, 8357c478bd9Sstevel@tonic-gate int alter, const char *nfound) 8367c478bd9Sstevel@tonic-gate { 8377c478bd9Sstevel@tonic-gate const char *str = MSG_ORIG(MSG_STR_EMPTY); 8387c478bd9Sstevel@tonic-gate const char *reject = MSG_ORIG(MSG_STR_EMPTY); 8397c478bd9Sstevel@tonic-gate char _reject[PATH_MAX]; 8407c478bd9Sstevel@tonic-gate 8417c478bd9Sstevel@tonic-gate /* 8427c478bd9Sstevel@tonic-gate * The first time through trace_so() will only have lddstub on the 8437c478bd9Sstevel@tonic-gate * link-map list and the preloaded shared object is supplied as "path". 8447c478bd9Sstevel@tonic-gate * As we don't want to print this shared object as a dependency, but 8457c478bd9Sstevel@tonic-gate * instead inspect *its* dependencies, return. 8467c478bd9Sstevel@tonic-gate */ 8477c478bd9Sstevel@tonic-gate if (FLAGS1(clmp) & FL1_RT_LDDSTUB) 8487c478bd9Sstevel@tonic-gate return; 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate /* 8517c478bd9Sstevel@tonic-gate * Without any rejection info, this is a supplied not-found condition. 8527c478bd9Sstevel@tonic-gate */ 8537c478bd9Sstevel@tonic-gate if (rej && (rej->rej_type == 0)) { 8547c478bd9Sstevel@tonic-gate (void) printf(nfound, name); 8557c478bd9Sstevel@tonic-gate return; 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate /* 8597c478bd9Sstevel@tonic-gate * If rejection information exists then establish what object was 8607c478bd9Sstevel@tonic-gate * found and the reason for its rejection. 8617c478bd9Sstevel@tonic-gate */ 8627c478bd9Sstevel@tonic-gate if (rej) { 863de777a60Sab196087 Conv_reject_desc_buf_t rej_buf; 864de777a60Sab196087 8657c478bd9Sstevel@tonic-gate /* LINTED */ 8667c478bd9Sstevel@tonic-gate (void) snprintf(_reject, PATH_MAX, 867de777a60Sab196087 MSG_INTL(ldd_reject[rej->rej_type]), 868ba2be530Sab196087 conv_reject_desc(rej, &rej_buf, M_MACH)); 8697c478bd9Sstevel@tonic-gate if (rej->rej_name) 8707c478bd9Sstevel@tonic-gate path = rej->rej_name; 8717c478bd9Sstevel@tonic-gate reject = (char *)_reject; 8727c478bd9Sstevel@tonic-gate 8737c478bd9Sstevel@tonic-gate /* 8747c478bd9Sstevel@tonic-gate * Was an alternative pathname defined (from a configuration 8757c478bd9Sstevel@tonic-gate * file). 8767c478bd9Sstevel@tonic-gate */ 87756deab07SRod Evans if (rej->rej_flags & FLG_REJ_ALTER) 8787c478bd9Sstevel@tonic-gate str = MSG_INTL(MSG_LDD_FIL_ALTER); 8797c478bd9Sstevel@tonic-gate } else { 8807c478bd9Sstevel@tonic-gate if (alter) 8817c478bd9Sstevel@tonic-gate str = MSG_INTL(MSG_LDD_FIL_ALTER); 8827c478bd9Sstevel@tonic-gate } 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate /* 8857c478bd9Sstevel@tonic-gate * If the load name isn't a full pathname print its associated pathname 8867c478bd9Sstevel@tonic-gate * together with all the other information we've gathered. 8877c478bd9Sstevel@tonic-gate */ 8887c478bd9Sstevel@tonic-gate if (*name == '/') 8897c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), path, str, reject); 8907c478bd9Sstevel@tonic-gate else 8917247f888Srie (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), name, path, str, 8927247f888Srie reject); 8937c478bd9Sstevel@tonic-gate } 8947c478bd9Sstevel@tonic-gate 8957c478bd9Sstevel@tonic-gate 8967c478bd9Sstevel@tonic-gate /* 8977c478bd9Sstevel@tonic-gate * Establish a link-map mode, initializing it if it has just been loaded, or 8987c478bd9Sstevel@tonic-gate * potentially updating it if it already exists. 8997c478bd9Sstevel@tonic-gate */ 9007c478bd9Sstevel@tonic-gate int 9017c478bd9Sstevel@tonic-gate update_mode(Rt_map *lmp, int omode, int nmode) 9027c478bd9Sstevel@tonic-gate { 903dffec89cSrie Lm_list *lml = LIST(lmp); 9047c478bd9Sstevel@tonic-gate int pmode = 0; 9057c478bd9Sstevel@tonic-gate 9067c478bd9Sstevel@tonic-gate /* 9077c478bd9Sstevel@tonic-gate * A newly loaded object hasn't had its mode set yet. Modes are used to 9087c478bd9Sstevel@tonic-gate * load dependencies, so don't propagate any parent or no-load flags, as 9097c478bd9Sstevel@tonic-gate * these would adversely affect this objects ability to load any of its 9107c478bd9Sstevel@tonic-gate * dependencies that aren't already loaded. RTLD_FIRST is applicable to 9117c478bd9Sstevel@tonic-gate * this objects handle creation only, and should not be propagated. 9127c478bd9Sstevel@tonic-gate */ 9137c478bd9Sstevel@tonic-gate if ((FLAGS(lmp) & FLG_RT_MODESET) == 0) { 9147c478bd9Sstevel@tonic-gate MODE(lmp) |= nmode & ~(RTLD_PARENT | RTLD_NOLOAD | RTLD_FIRST); 9157c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_MODESET; 9167c478bd9Sstevel@tonic-gate return (1); 9177c478bd9Sstevel@tonic-gate } 9187c478bd9Sstevel@tonic-gate 9197c478bd9Sstevel@tonic-gate /* 9207c478bd9Sstevel@tonic-gate * Establish any new overriding modes. RTLD_LAZY and RTLD_NOW should be 9217c478bd9Sstevel@tonic-gate * represented individually (this is historic, as these two flags were 9227c478bd9Sstevel@tonic-gate * the only flags originally available to dlopen()). Other flags are 9237c478bd9Sstevel@tonic-gate * accumulative, but have a hierarchy of preference. 9247c478bd9Sstevel@tonic-gate */ 9257c478bd9Sstevel@tonic-gate if ((omode & RTLD_LAZY) && (nmode & RTLD_NOW)) { 9267c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_LAZY; 9277c478bd9Sstevel@tonic-gate pmode |= RTLD_NOW; 9287c478bd9Sstevel@tonic-gate } 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate pmode |= ((~omode & nmode) & 9317c478bd9Sstevel@tonic-gate (RTLD_GLOBAL | RTLD_WORLD | RTLD_NODELETE)); 9327c478bd9Sstevel@tonic-gate if (pmode) { 9335aefb655Srie DBG_CALL(Dbg_file_mode_promote(lmp, pmode)); 9347c478bd9Sstevel@tonic-gate MODE(lmp) |= pmode; 9357c478bd9Sstevel@tonic-gate } 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate /* 9387c478bd9Sstevel@tonic-gate * If this load is an RTLD_NOW request and the object has already been 9397c478bd9Sstevel@tonic-gate * loaded non-RTLD_NOW, append this object to the relocation-now list 9407c478bd9Sstevel@tonic-gate * of the objects associated control list. Note, if the object hasn't 9417c478bd9Sstevel@tonic-gate * yet been relocated, setting its MODE() to RTLD_NOW will establish 9427c478bd9Sstevel@tonic-gate * full relocation processing when it eventually gets relocated. 9437c478bd9Sstevel@tonic-gate */ 9447c478bd9Sstevel@tonic-gate if ((pmode & RTLD_NOW) && 9457c478bd9Sstevel@tonic-gate (FLAGS(lmp) & (FLG_RT_RELOCED | FLG_RT_RELOCING))) { 9467c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate /* LINTED */ 949cce0e03bSab196087 lmc = (Lm_cntl *)alist_item_by_offset(LIST(lmp)->lm_lists, 950cce0e03bSab196087 CNTL(lmp)); 951cce0e03bSab196087 (void) aplist_append(&lmc->lc_now, lmp, AL_CNT_LMNOW); 9527c478bd9Sstevel@tonic-gate } 9537c478bd9Sstevel@tonic-gate 9547c478bd9Sstevel@tonic-gate /* 955dffec89cSrie * If this objects .init has been collected but has not yet been called, 956dffec89cSrie * it may be necessary to reevaluate the object using tsort(). For 9577c478bd9Sstevel@tonic-gate * example, a new dlopen() hierarchy may bind to uninitialized objects 9587c478bd9Sstevel@tonic-gate * that are already loaded, or a dlopen(RTLD_NOW) can establish new 9597c478bd9Sstevel@tonic-gate * bindings between already loaded objects that require the tsort() 960dffec89cSrie * information be recomputed. If however, no new objects have been 961dffec89cSrie * added to the process, and this object hasn't been promoted, don't 962dffec89cSrie * bother reevaluating the .init. The present tsort() information is 963dffec89cSrie * probably as accurate as necessary, and by not establishing a parallel 964dffec89cSrie * tsort() we can help reduce the amount of recursion possible between 965dffec89cSrie * .inits. 9667c478bd9Sstevel@tonic-gate */ 967dffec89cSrie if (((FLAGS(lmp) & 968dffec89cSrie (FLG_RT_INITCLCT | FLG_RT_INITCALL)) == FLG_RT_INITCLCT) && 969dffec89cSrie ((lml->lm_flags & LML_FLG_OBJADDED) || ((pmode & RTLD_NOW) && 970dffec89cSrie (FLAGS(lmp) & (FLG_RT_RELOCED | FLG_RT_RELOCING))))) { 9717c478bd9Sstevel@tonic-gate FLAGS(lmp) &= ~FLG_RT_INITCLCT; 9727c478bd9Sstevel@tonic-gate LIST(lmp)->lm_init++; 973dffec89cSrie LIST(lmp)->lm_flags |= LML_FLG_OBJREEVAL; 9747c478bd9Sstevel@tonic-gate } 9757c478bd9Sstevel@tonic-gate 9767c478bd9Sstevel@tonic-gate return (pmode); 9777c478bd9Sstevel@tonic-gate } 9787c478bd9Sstevel@tonic-gate 9797c478bd9Sstevel@tonic-gate /* 9807c478bd9Sstevel@tonic-gate * Determine whether an alias name already exists, and if not create one. This 9817c478bd9Sstevel@tonic-gate * is typically used to retain dependency names, such as "libc.so.1", which 9827c478bd9Sstevel@tonic-gate * would have been expanded to full path names when they were loaded. The 98356deab07SRod Evans * full path names (NAME() and possibly PATHNAME()) are maintained on the 98456deab07SRod Evans * FullPathNode AVL tree, and thus would have been matched by fpavl_loaded() 98556deab07SRod Evans * during file_open(). 9867c478bd9Sstevel@tonic-gate */ 9877c478bd9Sstevel@tonic-gate int 9887c478bd9Sstevel@tonic-gate append_alias(Rt_map *lmp, const char *str, int *added) 9897c478bd9Sstevel@tonic-gate { 99056deab07SRod Evans const char *cp; 991cce0e03bSab196087 Aliste idx; 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate /* 9947c478bd9Sstevel@tonic-gate * Determine if this filename is already on the alias list. 9957c478bd9Sstevel@tonic-gate */ 996cce0e03bSab196087 for (APLIST_TRAVERSE(ALIAS(lmp), idx, cp)) { 997cce0e03bSab196087 if (strcmp(cp, str) == 0) 9987c478bd9Sstevel@tonic-gate return (1); 9997c478bd9Sstevel@tonic-gate } 10007c478bd9Sstevel@tonic-gate 10017c478bd9Sstevel@tonic-gate /* 10027c478bd9Sstevel@tonic-gate * This is a new alias, append it to the alias list. 10037c478bd9Sstevel@tonic-gate */ 100456deab07SRod Evans if (((cp = stravl_insert(str, 0, 0, 0)) == NULL) || 100556deab07SRod Evans (aplist_append(&ALIAS(lmp), cp, AL_CNT_ALIAS) == NULL)) 10067c478bd9Sstevel@tonic-gate return (0); 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate if (added) 10097c478bd9Sstevel@tonic-gate *added = 1; 10107c478bd9Sstevel@tonic-gate return (1); 10117c478bd9Sstevel@tonic-gate } 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate /* 10147c478bd9Sstevel@tonic-gate * Determine whether a file is already loaded by comparing device and inode 10157c478bd9Sstevel@tonic-gate * values. 10167c478bd9Sstevel@tonic-gate */ 10177c478bd9Sstevel@tonic-gate static Rt_map * 1018cb511613SAli Bahrami is_devinode_loaded(rtld_stat_t *status, Lm_list *lml, const char *name, 10197c478bd9Sstevel@tonic-gate uint_t flags) 10207c478bd9Sstevel@tonic-gate { 10217c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 1022cce0e03bSab196087 Aliste idx; 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate /* 10257c478bd9Sstevel@tonic-gate * If this is an auditor, it will have been opened on a new link-map. 10268af2c5b9Srie * To prevent multiple occurrences of the same auditor on multiple 10277c478bd9Sstevel@tonic-gate * link-maps, search the head of each link-map list and see if this 10287c478bd9Sstevel@tonic-gate * object is already loaded as an auditor. 10297c478bd9Sstevel@tonic-gate */ 10307c478bd9Sstevel@tonic-gate if (flags & FLG_RT_AUDIT) { 10317c478bd9Sstevel@tonic-gate Lm_list *lml; 10327c478bd9Sstevel@tonic-gate 103357ef7aa9SRod Evans for (APLIST_TRAVERSE(dynlm_list, idx, lml)) { 10347c478bd9Sstevel@tonic-gate Rt_map *nlmp = lml->lm_head; 10357c478bd9Sstevel@tonic-gate 10367c478bd9Sstevel@tonic-gate if (nlmp && ((FLAGS(nlmp) & 10377c478bd9Sstevel@tonic-gate (FLG_RT_AUDIT | FLG_RT_DELETE)) == FLG_RT_AUDIT) && 10387c478bd9Sstevel@tonic-gate (STDEV(nlmp) == status->st_dev) && 10397c478bd9Sstevel@tonic-gate (STINO(nlmp) == status->st_ino)) 10407c478bd9Sstevel@tonic-gate return (nlmp); 10417c478bd9Sstevel@tonic-gate } 104237ffaf83SRod Evans return (NULL); 10437c478bd9Sstevel@tonic-gate } 10447c478bd9Sstevel@tonic-gate 10457c478bd9Sstevel@tonic-gate /* 10467c478bd9Sstevel@tonic-gate * If the file has been found determine from the new files status 10477c478bd9Sstevel@tonic-gate * information if this file is actually linked to one we already have 10487c478bd9Sstevel@tonic-gate * mapped. This catches symlink names not caught by is_so_loaded(). 10497c478bd9Sstevel@tonic-gate */ 1050cce0e03bSab196087 for (ALIST_TRAVERSE(lml->lm_lists, idx, lmc)) { 10517c478bd9Sstevel@tonic-gate Rt_map *nlmp; 10527c478bd9Sstevel@tonic-gate 1053cb511613SAli Bahrami for (nlmp = lmc->lc_head; nlmp; nlmp = NEXT_RT_MAP(nlmp)) { 10547c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) & FLG_RT_DELETE) || 10557c478bd9Sstevel@tonic-gate (FLAGS1(nlmp) & FL1_RT_LDDSTUB)) 10567c478bd9Sstevel@tonic-gate continue; 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate if ((STDEV(nlmp) != status->st_dev) || 10597c478bd9Sstevel@tonic-gate (STINO(nlmp) != status->st_ino)) 10607c478bd9Sstevel@tonic-gate continue; 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_VERBOSE) { 10637247f888Srie /* BEGIN CSTYLED */ 10647c478bd9Sstevel@tonic-gate if (*name == '/') 10657c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), 10667c478bd9Sstevel@tonic-gate name, MSG_ORIG(MSG_STR_EMPTY), 10677c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 10687c478bd9Sstevel@tonic-gate else 10697c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), 10707c478bd9Sstevel@tonic-gate name, NAME(nlmp), 10717c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY), 10727c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 10737247f888Srie /* END CSTYLED */ 10747c478bd9Sstevel@tonic-gate } 10757c478bd9Sstevel@tonic-gate return (nlmp); 10767c478bd9Sstevel@tonic-gate } 10777c478bd9Sstevel@tonic-gate } 107837ffaf83SRod Evans return (NULL); 10797c478bd9Sstevel@tonic-gate } 10807c478bd9Sstevel@tonic-gate 10817c478bd9Sstevel@tonic-gate /* 10827c478bd9Sstevel@tonic-gate * Generate any error messages indicating a file could not be found. When 10837c478bd9Sstevel@tonic-gate * preloading or auditing a secure application, it can be a little more helpful 10847c478bd9Sstevel@tonic-gate * to indicate that a search of secure directories has failed, so adjust the 10857c478bd9Sstevel@tonic-gate * messages accordingly. 10867c478bd9Sstevel@tonic-gate */ 10877c478bd9Sstevel@tonic-gate void 10887c478bd9Sstevel@tonic-gate file_notfound(Lm_list *lml, const char *name, Rt_map *clmp, uint_t flags, 10897c478bd9Sstevel@tonic-gate Rej_desc *rej) 10907c478bd9Sstevel@tonic-gate { 10917c478bd9Sstevel@tonic-gate int secure = 0; 10927c478bd9Sstevel@tonic-gate 10937c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SECURE) && 10947c478bd9Sstevel@tonic-gate (flags & (FLG_RT_PRELOAD | FLG_RT_AUDIT))) 10957c478bd9Sstevel@tonic-gate secure++; 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) { 10987c478bd9Sstevel@tonic-gate /* 10997c478bd9Sstevel@tonic-gate * Under ldd(1), auxiliary filtees that can't be loaded are 11007c478bd9Sstevel@tonic-gate * ignored, unless verbose errors are requested. 11017c478bd9Sstevel@tonic-gate */ 11027c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SILENCERR) && 11037c478bd9Sstevel@tonic-gate ((lml->lm_flags & LML_FLG_TRC_VERBOSE) == 0)) 11047c478bd9Sstevel@tonic-gate return; 11057c478bd9Sstevel@tonic-gate 11067c478bd9Sstevel@tonic-gate if (secure) 11077c478bd9Sstevel@tonic-gate trace_so(clmp, rej, name, 0, 0, 11087c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_SEC_NFOUND)); 11097c478bd9Sstevel@tonic-gate else 11107c478bd9Sstevel@tonic-gate trace_so(clmp, rej, name, 0, 0, 11117c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_FIL_NFOUND)); 11127c478bd9Sstevel@tonic-gate return; 11137c478bd9Sstevel@tonic-gate } 11147c478bd9Sstevel@tonic-gate 11157c478bd9Sstevel@tonic-gate if (rej->rej_type) { 1116de777a60Sab196087 Conv_reject_desc_buf_t rej_buf; 1117de777a60Sab196087 11185aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(err_reject[rej->rej_type]), 11197c478bd9Sstevel@tonic-gate rej->rej_name ? rej->rej_name : MSG_INTL(MSG_STR_UNKNOWN), 1120ba2be530Sab196087 conv_reject_desc(rej, &rej_buf, M_MACH)); 11217c478bd9Sstevel@tonic-gate return; 11227c478bd9Sstevel@tonic-gate } 11237c478bd9Sstevel@tonic-gate 11247c478bd9Sstevel@tonic-gate if (secure) 11255aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SEC_OPEN), name); 11267c478bd9Sstevel@tonic-gate else 11275aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), name, 11287c478bd9Sstevel@tonic-gate strerror(ENOENT)); 11297c478bd9Sstevel@tonic-gate } 11307c478bd9Sstevel@tonic-gate 11317c478bd9Sstevel@tonic-gate static int 113256deab07SRod Evans file_open(int err, Lm_list *lml, Rt_map *clmp, uint_t flags, Fdesc *fdp, 113356deab07SRod Evans Rej_desc *rej, int *in_nfavl) 11347c478bd9Sstevel@tonic-gate { 1135cb511613SAli Bahrami rtld_stat_t status; 11367c478bd9Sstevel@tonic-gate Rt_map *nlmp; 11379aa23310Srie avl_index_t nfavlwhere = 0; 113856deab07SRod Evans const char *oname = fdp->fd_oname, *nname = fdp->fd_nname; 113956deab07SRod Evans uint_t hash = sgs_str_hash(nname); 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate 114256deab07SRod Evans if ((nname = stravl_insert(fdp->fd_nname, hash, 0, 0)) == NULL) 114356deab07SRod Evans return (0); 114456deab07SRod Evans fdp->fd_nname = nname; 114556deab07SRod Evans 114656deab07SRod Evans if ((err == 0) && (fdp->fd_flags & FLG_FD_ALTER)) 11475aefb655Srie DBG_CALL(Dbg_file_config_obj(lml, oname, 0, nname)); 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate /* 11507c478bd9Sstevel@tonic-gate * If we're dealing with a full pathname, determine whether this 11517c478bd9Sstevel@tonic-gate * pathname is already known. Other pathnames fall through to the 11527c478bd9Sstevel@tonic-gate * dev/inode check, as even though the pathname may look the same as 11537c478bd9Sstevel@tonic-gate * one previously used, the process may have changed directory. 11547c478bd9Sstevel@tonic-gate */ 11557c478bd9Sstevel@tonic-gate if ((err == 0) && (nname[0] == '/')) { 115656deab07SRod Evans if ((nlmp = fpavl_recorded(lml, nname, hash, 115756deab07SRod Evans &(fdp->fd_avlwhere))) != NULL) { 115856deab07SRod Evans fdp->fd_lmp = nlmp; 11597c478bd9Sstevel@tonic-gate return (1); 11607c478bd9Sstevel@tonic-gate } 116156deab07SRod Evans if (nfavl_recorded(nname, hash, &nfavlwhere)) { 11629aa23310Srie /* 11639aa23310Srie * For dlopen() and dlsym() fall backs, indicate that 11649aa23310Srie * a registered not-found path has indicated that this 11659aa23310Srie * object does not exist. If this path has been 11669aa23310Srie * constructed as part of expanding a HWCAP directory, 116756deab07SRod Evans * this is a silent failure, where no rejection message 116856deab07SRod Evans * is created. 11699aa23310Srie */ 11709aa23310Srie if (in_nfavl) 11719aa23310Srie (*in_nfavl)++; 11729aa23310Srie return (0); 11739aa23310Srie } 11747c478bd9Sstevel@tonic-gate } 11757c478bd9Sstevel@tonic-gate 1176cb511613SAli Bahrami if ((err == 0) && ((rtld_stat(nname, &status)) != -1)) { 11777c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 11787c478bd9Sstevel@tonic-gate int fd, size, added; 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate /* 11817c478bd9Sstevel@tonic-gate * If this path has been constructed as part of expanding a 11828521e5e6Srie * HWCAP directory, ignore any subdirectories. As this is a 118356deab07SRod Evans * silent failure, no rejection message is created. For any 118456deab07SRod Evans * other reference that expands to a directory, fall through 11858af2c5b9Srie * to construct a meaningful rejection message. 11867c478bd9Sstevel@tonic-gate */ 11877c478bd9Sstevel@tonic-gate if ((flags & FLG_RT_HWCAP) && 118856deab07SRod Evans ((status.st_mode & S_IFMT) == S_IFDIR)) 118956deab07SRod Evans return (0); 119056deab07SRod Evans 119156deab07SRod Evans /* 119256deab07SRod Evans * If this is a directory (which can't be mmap()'ed) generate a 119356deab07SRod Evans * precise error message. 119456deab07SRod Evans */ 119556deab07SRod Evans if ((status.st_mode & S_IFMT) == S_IFDIR) { 119656deab07SRod Evans rej->rej_name = nname; 119756deab07SRod Evans if (fdp->fd_flags & FLG_FD_ALTER) 119856deab07SRod Evans rej->rej_flags = FLG_REJ_ALTER; 119956deab07SRod Evans rej->rej_type = SGS_REJ_STR; 120056deab07SRod Evans rej->rej_str = strerror(EISDIR); 120156deab07SRod Evans DBG_CALL(Dbg_file_rejected(lml, rej, M_MACH)); 12027c478bd9Sstevel@tonic-gate return (0); 12038521e5e6Srie } 12047c478bd9Sstevel@tonic-gate 12057c478bd9Sstevel@tonic-gate /* 12067c478bd9Sstevel@tonic-gate * Resolve the filename and determine whether the resolved name 12077c478bd9Sstevel@tonic-gate * is already known. Typically, the previous fpavl_loaded() 12087c478bd9Sstevel@tonic-gate * will have caught this, as both NAME() and PATHNAME() for a 120956deab07SRod Evans * link-map are recorded in the FullPathNode AVL tree. However, 12107c478bd9Sstevel@tonic-gate * instances exist where a file can be replaced (loop-back 12117c478bd9Sstevel@tonic-gate * mounts, bfu, etc.), and reference is made to the original 12127c478bd9Sstevel@tonic-gate * file through a symbolic link. By checking the pathname here, 12137c478bd9Sstevel@tonic-gate * we don't fall through to the dev/inode check and conclude 12147c478bd9Sstevel@tonic-gate * that a new file should be loaded. 12157c478bd9Sstevel@tonic-gate */ 121656deab07SRod Evans if ((nname[0] == '/') && 12177c478bd9Sstevel@tonic-gate ((size = resolvepath(nname, path, (PATH_MAX - 1))) > 0)) { 12187c478bd9Sstevel@tonic-gate path[size] = '\0'; 12197c478bd9Sstevel@tonic-gate 122056deab07SRod Evans fdp->fd_flags |= FLG_FD_RESOLVED; 122156deab07SRod Evans 12227c478bd9Sstevel@tonic-gate if (strcmp(nname, path)) { 122324a6229eSrie if ((nlmp = 122456deab07SRod Evans fpavl_recorded(lml, path, 0, 0)) != NULL) { 12257c478bd9Sstevel@tonic-gate added = 0; 12267c478bd9Sstevel@tonic-gate 12277c478bd9Sstevel@tonic-gate if (append_alias(nlmp, nname, 12287c478bd9Sstevel@tonic-gate &added) == 0) 12297c478bd9Sstevel@tonic-gate return (0); 12307247f888Srie /* BEGIN CSTYLED */ 12317c478bd9Sstevel@tonic-gate if (added) 123210a4fa49Srie DBG_CALL(Dbg_file_skip(LIST(clmp), 12335aefb655Srie NAME(nlmp), nname)); 12347247f888Srie /* END CSTYLED */ 123556deab07SRod Evans fdp->fd_lmp = nlmp; 12367c478bd9Sstevel@tonic-gate return (1); 12377c478bd9Sstevel@tonic-gate } 12387c478bd9Sstevel@tonic-gate 12397c478bd9Sstevel@tonic-gate /* 12407c478bd9Sstevel@tonic-gate * If this pathname hasn't been loaded, save 12417c478bd9Sstevel@tonic-gate * the resolved pathname so that it doesn't 12427c478bd9Sstevel@tonic-gate * have to be recomputed as part of fullpath() 12437c478bd9Sstevel@tonic-gate * processing. 12447c478bd9Sstevel@tonic-gate */ 124556deab07SRod Evans if ((fdp->fd_pname = stravl_insert(path, 0, 124656deab07SRod Evans (size + 1), 0)) == NULL) 12477c478bd9Sstevel@tonic-gate return (0); 12487c478bd9Sstevel@tonic-gate } 12497c478bd9Sstevel@tonic-gate } 12507c478bd9Sstevel@tonic-gate 12517c478bd9Sstevel@tonic-gate if (nlmp = is_devinode_loaded(&status, lml, nname, flags)) { 1252c75e1b9dSrie if (flags & FLG_RT_AUDIT) { 1253c75e1b9dSrie /* 1254c75e1b9dSrie * If we've been requested to load an auditor, 1255c75e1b9dSrie * and an auditor of the same name already 1256c75e1b9dSrie * exists, then the original auditor is used. 1257c75e1b9dSrie */ 1258c75e1b9dSrie DBG_CALL(Dbg_audit_skip(LIST(clmp), 1259c75e1b9dSrie NAME(nlmp), LIST(nlmp)->lm_lmidstr)); 1260c75e1b9dSrie } else { 1261c75e1b9dSrie /* 1262c75e1b9dSrie * Otherwise, if an alternatively named file 1263c75e1b9dSrie * has been found for the same dev/inode, add 126456deab07SRod Evans * a new name alias. Insert any alias full path 126556deab07SRod Evans * name in the FullPathNode AVL tree. 1266c75e1b9dSrie */ 12677c478bd9Sstevel@tonic-gate added = 0; 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate if (append_alias(nlmp, nname, &added) == 0) 12707c478bd9Sstevel@tonic-gate return (0); 12717c478bd9Sstevel@tonic-gate if (added) { 1272c75e1b9dSrie if ((nname[0] == '/') && 1273c75e1b9dSrie (fpavl_insert(lml, nlmp, 1274c75e1b9dSrie nname, 0) == 0)) 12757c478bd9Sstevel@tonic-gate return (0); 1276c75e1b9dSrie DBG_CALL(Dbg_file_skip(LIST(clmp), 1277c75e1b9dSrie NAME(nlmp), nname)); 12787c478bd9Sstevel@tonic-gate } 1279c75e1b9dSrie } 1280c75e1b9dSrie 1281c75e1b9dSrie /* 1282c75e1b9dSrie * Record in the file descriptor the existing object 1283c75e1b9dSrie * that satisfies this open request. 1284c75e1b9dSrie */ 128556deab07SRod Evans fdp->fd_lmp = nlmp; 12867c478bd9Sstevel@tonic-gate return (1); 12877c478bd9Sstevel@tonic-gate } 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate if ((fd = open(nname, O_RDONLY, 0)) == -1) { 12907c478bd9Sstevel@tonic-gate /* 12917c478bd9Sstevel@tonic-gate * As the file must exist for the previous stat() to 12927c478bd9Sstevel@tonic-gate * have succeeded, record the error condition. 12937c478bd9Sstevel@tonic-gate */ 12947c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_STR; 12957c478bd9Sstevel@tonic-gate rej->rej_str = strerror(errno); 12967c478bd9Sstevel@tonic-gate } else { 129756deab07SRod Evans /* 129856deab07SRod Evans * Map the object. A successful return indicates that 129956deab07SRod Evans * the object is appropriate for ld.so.1 processing. 130056deab07SRod Evans */ 130156deab07SRod Evans fdp->fd_ftp = map_obj(lml, fdp, status.st_size, nname, 130256deab07SRod Evans fd, rej); 130356deab07SRod Evans (void) close(fd); 13047c478bd9Sstevel@tonic-gate 130556deab07SRod Evans if (fdp->fd_ftp != NULL) { 130656deab07SRod Evans fdp->fd_dev = status.st_dev; 130756deab07SRod Evans fdp->fd_ino = status.st_ino; 13087c478bd9Sstevel@tonic-gate 13097c478bd9Sstevel@tonic-gate /* 13107c478bd9Sstevel@tonic-gate * Trace that this open has succeeded. 13117c478bd9Sstevel@tonic-gate */ 13127c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) { 13137c478bd9Sstevel@tonic-gate trace_so(clmp, 0, oname, nname, 131456deab07SRod Evans (fdp->fd_flags & FLG_FD_ALTER), 0); 13157c478bd9Sstevel@tonic-gate } 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 13297c478bd9Sstevel@tonic-gate /* 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 13369aa23310Srie /* 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; 1343ba2be530Sab196087 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 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; 13567c478bd9Sstevel@tonic-gate 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 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; 14427c478bd9Sstevel@tonic-gate } 144356deab07SRod Evans } 144456deab07SRod Evans return (file_open(0, lml, clmp, flags, fdp, rej, in_nfavl)); 14457c478bd9Sstevel@tonic-gate } 14467c478bd9Sstevel@tonic-gate 1447390b98b5Srie static int 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 }; 14527c478bd9Sstevel@tonic-gate 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) { 149556deab07SRod Evans if (*strhash == NULL) 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)); 15467c478bd9Sstevel@tonic-gate 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)); 155356deab07SRod Evans } 155456deab07SRod Evans 155556deab07SRod Evans static Fct *Vector[] = { 155656deab07SRod Evans &elf_fct, 155756deab07SRod Evans #ifdef A_OUT 155856deab07SRod Evans &aout_fct, 155956deab07SRod Evans #endif 156056deab07SRod Evans 0 156156deab07SRod Evans }; 156256deab07SRod Evans 156356deab07SRod Evans /* 156456deab07SRod Evans * Remap the first page of a file to provide a better diagnostic as to why 156556deab07SRod Evans * an mmapobj(2) operation on this file failed. Sadly, mmapobj(), and all 156656deab07SRod Evans * system calls for that matter, only pass back a generic failure in errno. 156756deab07SRod Evans * Hopefully one day this will be improved, but in the mean time we repeat 156856deab07SRod Evans * the kernels ELF verification to try and provide more detailed information. 156956deab07SRod Evans */ 157056deab07SRod Evans static int 157156deab07SRod Evans map_fail(Fdesc *fdp, size_t fsize, const char *name, int fd, Rej_desc *rej) 157256deab07SRod Evans { 157356deab07SRod Evans caddr_t addr; 157456deab07SRod Evans int vnum; 157556deab07SRod Evans size_t size; 157656deab07SRod Evans 157756deab07SRod Evans /* 157856deab07SRod Evans * Use the original file size to determine what to map, and catch the 157956deab07SRod Evans * obvious error of a zero sized file. 158056deab07SRod Evans */ 158156deab07SRod Evans if (fsize == 0) { 158256deab07SRod Evans rej->rej_type = SGS_REJ_UNKFILE; 158356deab07SRod Evans return (1); 158456deab07SRod Evans } else if (fsize < syspagsz) 158556deab07SRod Evans size = fsize; 158656deab07SRod Evans else 158756deab07SRod Evans size = syspagsz; 158856deab07SRod Evans 158956deab07SRod Evans if ((addr = mmap(0, size, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED) 159056deab07SRod Evans return (0); 159156deab07SRod Evans 159256deab07SRod Evans rej->rej_type = 0; 159356deab07SRod Evans 159456deab07SRod Evans /* 159556deab07SRod Evans * Validate the file against each supported file type. Should a 159656deab07SRod Evans * characteristic of the file be found invalid for this platform, a 159756deab07SRod Evans * rejection message will have been recorded. 159856deab07SRod Evans */ 159956deab07SRod Evans for (vnum = 0; Vector[vnum]; vnum++) { 160056deab07SRod Evans if (((Vector[vnum]->fct_verify_file)(addr, size, 160156deab07SRod Evans fdp, name, rej) == 0) && rej->rej_type) 160256deab07SRod Evans break; 160356deab07SRod Evans } 160456deab07SRod Evans 160556deab07SRod Evans /* 160656deab07SRod Evans * If no rejection message has been recorded, then this is simply an 160756deab07SRod Evans * unknown file type. 160856deab07SRod Evans */ 160956deab07SRod Evans if (rej->rej_type == 0) 161056deab07SRod Evans rej->rej_type = SGS_REJ_UNKFILE; 161156deab07SRod Evans 161256deab07SRod Evans (void) munmap(addr, size); 161356deab07SRod Evans return (1); 161456deab07SRod Evans } 161556deab07SRod Evans 161656deab07SRod Evans /* 161756deab07SRod Evans * Unmap a file. 161856deab07SRod Evans */ 161956deab07SRod Evans void 162056deab07SRod Evans unmap_obj(mmapobj_result_t *mpp, uint_t mapnum) 162156deab07SRod Evans { 162256deab07SRod Evans uint_t num; 162356deab07SRod Evans 162456deab07SRod Evans for (num = 0; num < mapnum; num++) { 162556deab07SRod Evans /* LINTED */ 162656deab07SRod Evans (void) munmap((void *)(uintptr_t)mpp[num].mr_addr, 162756deab07SRod Evans mpp[num].mr_msize); 162856deab07SRod Evans } 162956deab07SRod Evans } 163056deab07SRod Evans 163156deab07SRod Evans /* 163256deab07SRod Evans * Map a file. 163356deab07SRod Evans */ 163456deab07SRod Evans Fct * 163556deab07SRod Evans map_obj(Lm_list *lml, Fdesc *fdp, size_t fsize, const char *name, int fd, 163656deab07SRod Evans Rej_desc *rej) 163756deab07SRod Evans { 163856deab07SRod Evans static mmapobj_result_t *smpp = NULL; 163956deab07SRod Evans static uint_t smapnum; 164056deab07SRod Evans mmapobj_result_t *mpp; 164156deab07SRod Evans uint_t mnum, mapnum, mflags; 164256deab07SRod Evans void *padding; 164356deab07SRod Evans 164456deab07SRod Evans /* 164556deab07SRod Evans * Allocate an initial mapping array. The initial size should be large 164656deab07SRod Evans * enough to handle the normal ELF objects we come across. 164756deab07SRod Evans */ 164856deab07SRod Evans if (smpp == NULL) { 164956deab07SRod Evans smpp = malloc(sizeof (mmapobj_result_t) * MMAPFD_NUM); 165056deab07SRod Evans if (smpp == NULL) 165156deab07SRod Evans return (NULL); 165256deab07SRod Evans smapnum = MMAPFD_NUM; 165356deab07SRod Evans } 165456deab07SRod Evans 165556deab07SRod Evans /* 165656deab07SRod Evans * If object padding is required, set the necessary flags. 165756deab07SRod Evans */ 165856deab07SRod Evans if (r_debug.rtd_objpad) { 165956deab07SRod Evans mflags = MMOBJ_INTERPRET | MMOBJ_PADDING; 166056deab07SRod Evans padding = &r_debug.rtd_objpad; 166156deab07SRod Evans } else { 166256deab07SRod Evans mflags = MMOBJ_INTERPRET; 166356deab07SRod Evans padding = NULL; 166456deab07SRod Evans } 166556deab07SRod Evans 166656deab07SRod Evans /* 166756deab07SRod Evans * Map the file. If the number of mappings required by this file 166856deab07SRod Evans * exceeds the present mapping structure, an error indicating the 166956deab07SRod Evans * return data is too big is returned. Bail on any other error. 167056deab07SRod Evans */ 167156deab07SRod Evans mapnum = smapnum; 167256deab07SRod Evans if (mmapobj(fd, mflags, smpp, &mapnum, padding) == -1) { 167356deab07SRod Evans if (errno != E2BIG) { 167456deab07SRod Evans int err = errno; 167556deab07SRod Evans 167656deab07SRod Evans /* 167756deab07SRod Evans * An unsupported error indicates that there's something 167856deab07SRod Evans * incompatible with this ELF file, and the process that 167956deab07SRod Evans * is already running. Map the first page of the file 168056deab07SRod Evans * and see if we can generate a better error message. 168156deab07SRod Evans */ 168256deab07SRod Evans if ((errno == ENOTSUP) && map_fail(fdp, fsize, name, 168356deab07SRod Evans fd, rej)) 168456deab07SRod Evans return (NULL); 168556deab07SRod Evans 168656deab07SRod Evans rej->rej_type = SGS_REJ_STR; 168756deab07SRod Evans rej->rej_str = strerror(err); 168856deab07SRod Evans return (NULL); 168956deab07SRod Evans } 169056deab07SRod Evans 169156deab07SRod Evans /* 169256deab07SRod Evans * The mapping requirement exceeds the present mapping 169356deab07SRod Evans * structure, however the number of mapping required is 169456deab07SRod Evans * available in the mapping number. 169556deab07SRod Evans */ 169656deab07SRod Evans free((void *)smpp); 169756deab07SRod Evans if ((smpp = malloc(sizeof (mmapobj_result_t) * mapnum)) == NULL) 169856deab07SRod Evans return (NULL); 169956deab07SRod Evans smapnum = mapnum; 170056deab07SRod Evans 170156deab07SRod Evans /* 170256deab07SRod Evans * With the appropriate mapping structure, try the mapping 170356deab07SRod Evans * request again. 170456deab07SRod Evans */ 170556deab07SRod Evans if (mmapobj(fd, mflags, smpp, &mapnum, padding) == -1) { 170656deab07SRod Evans rej->rej_type = SGS_REJ_STR; 170756deab07SRod Evans rej->rej_str = strerror(errno); 170856deab07SRod Evans return (NULL); 170956deab07SRod Evans } 171056deab07SRod Evans } 171156deab07SRod Evans ASSERT(mapnum != 0); 171256deab07SRod Evans 171356deab07SRod Evans /* 171456deab07SRod Evans * Traverse the mappings in search of a file type ld.so.1 can process. 171556deab07SRod Evans * If the file type is verified as one ld.so.1 can process, retain the 171656deab07SRod Evans * mapping information, and the number of mappings this object uses, 171756deab07SRod Evans * and clear the static mapping pointer for the next map_obj() use of 171856deab07SRod Evans * mmapobj(). 171956deab07SRod Evans */ 172056deab07SRod Evans DBG_CALL(Dbg_file_mmapobj(lml, name, smpp, mapnum)); 172156deab07SRod Evans 172256deab07SRod Evans for (mnum = 0, mpp = smpp; mnum < mapnum; mnum++, mpp++) { 172356deab07SRod Evans uint_t flags = (mpp->mr_flags & MR_TYPE_MASK); 172456deab07SRod Evans Fct *fptr = NULL; 172556deab07SRod Evans 172656deab07SRod Evans if (flags == MR_HDR_ELF) { 172756deab07SRod Evans fptr = elf_verify((mpp->mr_addr + mpp->mr_offset), 172856deab07SRod Evans mpp->mr_fsize, fdp, name, rej); 172956deab07SRod Evans } 173056deab07SRod Evans #ifdef A_OUT 173156deab07SRod Evans if (flags == MR_HDR_AOUT) { 173256deab07SRod Evans fptr = aout_verify((mpp->mr_addr + mpp->mr_offset), 173356deab07SRod Evans mpp->mr_fsize, fdp, name, rej); 173456deab07SRod Evans } 173556deab07SRod Evans #endif 173656deab07SRod Evans if (fptr) { 173756deab07SRod Evans fdp->fd_mapn = mapnum; 173856deab07SRod Evans fdp->fd_mapp = smpp; 173956deab07SRod Evans 174056deab07SRod Evans smpp = NULL; 174156deab07SRod Evans 174256deab07SRod Evans return (fptr); 174356deab07SRod Evans } 174456deab07SRod Evans } 174556deab07SRod Evans 174656deab07SRod Evans /* 174756deab07SRod Evans * If the mapped file is inappropriate, indicate that the file type is 174856deab07SRod Evans * unknown, and free the mapping. 174956deab07SRod Evans */ 175056deab07SRod Evans if (rej->rej_type == 0) 175156deab07SRod Evans rej->rej_type = SGS_REJ_UNKFILE; 175256deab07SRod Evans unmap_obj(smpp, mapnum); 175356deab07SRod Evans 175456deab07SRod Evans return (NULL); 17557c478bd9Sstevel@tonic-gate } 17567c478bd9Sstevel@tonic-gate 17577c478bd9Sstevel@tonic-gate /* 17587c478bd9Sstevel@tonic-gate * A unique file has been opened. Create a link-map to represent it, and 17597c478bd9Sstevel@tonic-gate * process the various names by which it can be referenced. 17607c478bd9Sstevel@tonic-gate */ 176156deab07SRod Evans Rt_map * 176256deab07SRod Evans load_file(Lm_list *lml, Aliste lmco, Fdesc *fdp, int *in_nfavl) 17637c478bd9Sstevel@tonic-gate { 176456deab07SRod Evans mmapobj_result_t *fpmpp = NULL, *fmpp = NULL, *lpmpp, *lmpp; 176556deab07SRod Evans mmapobj_result_t *hmpp, *mpp, *ompp = fdp->fd_mapp; 176656deab07SRod Evans uint_t mnum, omapnum = fdp->fd_mapn; 176756deab07SRod Evans const char *nname = fdp->fd_nname; 17687c478bd9Sstevel@tonic-gate Rt_map *nlmp; 176956deab07SRod Evans Ehdr *ehdr = NULL; 17707c478bd9Sstevel@tonic-gate 17717c478bd9Sstevel@tonic-gate /* 177256deab07SRod Evans * Traverse the mappings for the input file to capture generic mapping 177356deab07SRod Evans * information, and create a link-map to represent the file. 17747c478bd9Sstevel@tonic-gate */ 177556deab07SRod Evans for (mnum = 0, mpp = ompp; mnum < omapnum; mnum++, mpp++) { 177656deab07SRod Evans uint_t flags = (mpp->mr_flags & MR_TYPE_MASK); 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate /* 177956deab07SRod Evans * Keep track of the first and last mappings that may include 178056deab07SRod Evans * padding. 17817c478bd9Sstevel@tonic-gate */ 178256deab07SRod Evans if (fpmpp == NULL) 178356deab07SRod Evans fpmpp = mpp; 178456deab07SRod Evans lpmpp = mpp; 17857c478bd9Sstevel@tonic-gate 178656deab07SRod Evans /* 178756deab07SRod Evans * Keep track of the first and last mappings that do not include 178856deab07SRod Evans * padding. 178956deab07SRod Evans */ 179056deab07SRod Evans if (flags != MR_PADDING) { 179156deab07SRod Evans if (fmpp == NULL) 179256deab07SRod Evans fmpp = mpp; 179356deab07SRod Evans lmpp = mpp; 179456deab07SRod Evans } 179556deab07SRod Evans if (flags == MR_HDR_ELF) { 179656deab07SRod Evans /* LINTED */ 179756deab07SRod Evans ehdr = (Ehdr *)(mpp->mr_addr + mpp->mr_offset); 179856deab07SRod Evans hmpp = mpp; 179956deab07SRod Evans } else if (flags == MR_HDR_AOUT) 180056deab07SRod Evans hmpp = mpp; 180156deab07SRod Evans } 180256deab07SRod Evans 180356deab07SRod Evans /* 180456deab07SRod Evans * The only ELF files we can handle are ET_EXEC, ET_DYN, and ET_REL. 180556deab07SRod Evans * 180656deab07SRod Evans * ET_REL must be processed by ld(1) to create an in-memory ET_DYN. 180756deab07SRod Evans * The initial processing carried out by elf_obj_file() creates a 180856deab07SRod Evans * temporary link-map, that acts as a place holder, until the objects 180956deab07SRod Evans * processing is finished with elf_obj_fini(). 181056deab07SRod Evans */ 181156deab07SRod Evans if (ehdr && (ehdr->e_type == ET_REL)) { 181256deab07SRod Evans if ((nlmp = elf_obj_file(lml, lmco, nname, hmpp, ompp, 181356deab07SRod Evans omapnum)) == NULL) 181456deab07SRod Evans return (nlmp); 181556deab07SRod Evans } else { 181656deab07SRod Evans Addr addr; 181756deab07SRod Evans size_t msize; 181856deab07SRod Evans 181956deab07SRod Evans /* 182056deab07SRod Evans * The size of the total reservation, and the padding range, 182156deab07SRod Evans * are a historic artifact required by debuggers. Although 182256deab07SRod Evans * these values express the range of the associated mappings, 182356deab07SRod Evans * there can be holes between segments (in which small objects 182456deab07SRod Evans * could be mapped). Anyone who needs to verify offsets 182556deab07SRod Evans * against segments should analyze all the object mappings, 182656deab07SRod Evans * rather than relying on these address ranges. 182756deab07SRod Evans */ 182856deab07SRod Evans addr = (Addr)(hmpp->mr_addr + hmpp->mr_offset); 182956deab07SRod Evans msize = lmpp->mr_addr + lmpp->mr_msize - fmpp->mr_addr; 183056deab07SRod Evans 183156deab07SRod Evans if ((nlmp = ((fdp->fd_ftp)->fct_new_lmp)(lml, lmco, fdp, addr, 183256deab07SRod Evans msize, NULL, in_nfavl)) == NULL) 183337ffaf83SRod Evans return (NULL); 18347c478bd9Sstevel@tonic-gate 18357c478bd9Sstevel@tonic-gate /* 183656deab07SRod Evans * Save generic mapping information. 18377c478bd9Sstevel@tonic-gate */ 183856deab07SRod Evans MMAPS(nlmp) = ompp; 183956deab07SRod Evans MMAPCNT(nlmp) = omapnum; 184056deab07SRod Evans PADSTART(nlmp) = (ulong_t)fpmpp->mr_addr; 184156deab07SRod Evans PADIMLEN(nlmp) = lpmpp->mr_addr + lpmpp->mr_msize - 184256deab07SRod Evans fpmpp->mr_addr; 184356deab07SRod Evans } 18447c478bd9Sstevel@tonic-gate 18457c478bd9Sstevel@tonic-gate /* 184656deab07SRod Evans * Save the dev/inode information for later comparisons, and identify 184756deab07SRod Evans * this as a new object. 18487c478bd9Sstevel@tonic-gate */ 184956deab07SRod Evans STDEV(nlmp) = fdp->fd_dev; 185056deab07SRod Evans STINO(nlmp) = fdp->fd_ino; 185156deab07SRod Evans FLAGS(nlmp) |= FLG_RT_NEWLOAD; 18527c478bd9Sstevel@tonic-gate 185356deab07SRod Evans /* 185456deab07SRod Evans * If this is ELF relocatable object, we're done for now. 185556deab07SRod Evans */ 185656deab07SRod Evans if (ehdr && (ehdr->e_type == ET_REL)) 185756deab07SRod Evans return (nlmp); 185856deab07SRod Evans 185956deab07SRod Evans /* 186056deab07SRod Evans * Insert the names of this link-map into the FullPathNode AVL tree. 186156deab07SRod Evans * Save both the NAME() and PATHNAME() if the names differ. 186256deab07SRod Evans */ 186356deab07SRod Evans (void) fullpath(nlmp, fdp); 186456deab07SRod Evans 186556deab07SRod Evans if ((NAME(nlmp)[0] == '/') && (fpavl_insert(lml, nlmp, NAME(nlmp), 186656deab07SRod Evans fdp->fd_avlwhere) == 0)) { 18677c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 186837ffaf83SRod Evans return (NULL); 18697c478bd9Sstevel@tonic-gate } 187056deab07SRod Evans if (((NAME(nlmp)[0] != '/') || (NAME(nlmp) != PATHNAME(nlmp))) && 18717c478bd9Sstevel@tonic-gate (fpavl_insert(lml, nlmp, PATHNAME(nlmp), 0) == 0)) { 18727c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 187337ffaf83SRod Evans return (NULL); 18747c478bd9Sstevel@tonic-gate } 18753dbfc803SRod Evans 18763dbfc803SRod Evans /* 187756deab07SRod Evans * If this is a secure application, record any full path name directory 187856deab07SRod Evans * in which this dependency has been found. This directory can be 187956deab07SRod Evans * deemed safe (as we've already found a dependency here). This 188056deab07SRod Evans * recording provides a fall-back should another objects $ORIGIN 188156deab07SRod Evans * definition expands to this directory, an expansion that would 188256deab07SRod Evans * ordinarily be deemed insecure. 18833dbfc803SRod Evans */ 18843dbfc803SRod Evans if (rtld_flags & RT_FL_SECURE) { 18853dbfc803SRod Evans if (NAME(nlmp)[0] == '/') 18863dbfc803SRod Evans spavl_insert(NAME(nlmp)); 18873dbfc803SRod Evans if ((NAME(nlmp) != PATHNAME(nlmp)) && 18883dbfc803SRod Evans (PATHNAME(nlmp)[0] == '/')) 18893dbfc803SRod Evans spavl_insert(PATHNAME(nlmp)); 18903dbfc803SRod Evans } 18917c478bd9Sstevel@tonic-gate 18927c478bd9Sstevel@tonic-gate /* 18937c478bd9Sstevel@tonic-gate * If we're processing an alternative object reset the original name 18947c478bd9Sstevel@tonic-gate * for possible $ORIGIN processing. 18957c478bd9Sstevel@tonic-gate */ 189656deab07SRod Evans if (fdp->fd_flags & FLG_FD_ALTER) { 189756deab07SRod Evans const char *odir, *ndir; 18987c478bd9Sstevel@tonic-gate size_t olen; 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate FLAGS(nlmp) |= FLG_RT_ALTER; 19017c478bd9Sstevel@tonic-gate 19027c478bd9Sstevel@tonic-gate /* 19037c478bd9Sstevel@tonic-gate * If we were given a pathname containing a slash then the 19047c478bd9Sstevel@tonic-gate * original name is still in oname. Otherwise the original 19057c478bd9Sstevel@tonic-gate * directory is in dir->p_name (which is all we need for 19067c478bd9Sstevel@tonic-gate * $ORIGIN). 19077c478bd9Sstevel@tonic-gate */ 190856deab07SRod Evans if (fdp->fd_flags & FLG_FD_SLASH) { 19097c478bd9Sstevel@tonic-gate char *ofil; 19107c478bd9Sstevel@tonic-gate 191156deab07SRod Evans odir = fdp->fd_oname; 191256deab07SRod Evans ofil = strrchr(fdp->fd_oname, '/'); 19137c478bd9Sstevel@tonic-gate olen = ofil - odir + 1; 19147c478bd9Sstevel@tonic-gate } else { 191556deab07SRod Evans odir = fdp->fd_odir; 19167c478bd9Sstevel@tonic-gate olen = strlen(odir) + 1; 19177c478bd9Sstevel@tonic-gate } 191856deab07SRod Evans if ((ndir = stravl_insert(odir, 0, olen, 1)) == NULL) { 19197c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 192037ffaf83SRod Evans return (NULL); 19217c478bd9Sstevel@tonic-gate } 19227c478bd9Sstevel@tonic-gate ORIGNAME(nlmp) = ndir; 192356deab07SRod Evans DIRSZ(nlmp) = --olen; 19247c478bd9Sstevel@tonic-gate } 19257c478bd9Sstevel@tonic-gate 19267c478bd9Sstevel@tonic-gate return (nlmp); 19277c478bd9Sstevel@tonic-gate } 19287c478bd9Sstevel@tonic-gate 19297c478bd9Sstevel@tonic-gate /* 19307c478bd9Sstevel@tonic-gate * This function loads the named file and returns a pointer to its link map. 19317c478bd9Sstevel@tonic-gate * It is assumed that the caller has already checked that the file is not 19327c478bd9Sstevel@tonic-gate * already loaded before calling this function (refer is_so_loaded()). 19337c478bd9Sstevel@tonic-gate * Find and open the file, map it into memory, add it to the end of the list 19347c478bd9Sstevel@tonic-gate * of link maps and return a pointer to the new link map. Return 0 on error. 19357c478bd9Sstevel@tonic-gate */ 19367c478bd9Sstevel@tonic-gate static Rt_map * 193756deab07SRod Evans load_so(Lm_list *lml, Aliste lmco, Rt_map *clmp, uint_t flags, 193856deab07SRod Evans Fdesc *fdp, Rej_desc *rej, int *in_nfavl) 19397c478bd9Sstevel@tonic-gate { 194056deab07SRod Evans const char *oname = fdp->fd_oname; 194156deab07SRod Evans Pdesc *pdp; 19427c478bd9Sstevel@tonic-gate 19437c478bd9Sstevel@tonic-gate /* 194456deab07SRod Evans * If this path name hasn't already been identified as containing a 194556deab07SRod Evans * slash, check the path name. Most paths have been constructed 194656deab07SRod Evans * through appending a file name to a search path, and/or have been 194756deab07SRod Evans * inspected by expand(), and thus have a slash. However, we can 194856deab07SRod Evans * receive path names via auditors or configuration files, and thus 194956deab07SRod Evans * an evaluation here catches these instances. 19507c478bd9Sstevel@tonic-gate */ 195156deab07SRod Evans if ((fdp->fd_flags & FLG_FD_SLASH) == 0) { 19527c478bd9Sstevel@tonic-gate const char *str; 19537c478bd9Sstevel@tonic-gate 19547c478bd9Sstevel@tonic-gate for (str = oname; *str; str++) { 19557c478bd9Sstevel@tonic-gate if (*str == '/') { 195656deab07SRod Evans fdp->fd_flags |= FLG_FD_SLASH; 19577c478bd9Sstevel@tonic-gate break; 19587c478bd9Sstevel@tonic-gate } 19597c478bd9Sstevel@tonic-gate } 19607c478bd9Sstevel@tonic-gate } 19617c478bd9Sstevel@tonic-gate 19627c478bd9Sstevel@tonic-gate /* 19637c478bd9Sstevel@tonic-gate * If we are passed a 'null' link-map this means that this is the first 19647c478bd9Sstevel@tonic-gate * object to be loaded on this link-map list. In that case we set the 19657c478bd9Sstevel@tonic-gate * link-map to ld.so.1's link-map. 19667c478bd9Sstevel@tonic-gate * 19677c478bd9Sstevel@tonic-gate * This link-map is referenced to determine what lookup rules to use 19687c478bd9Sstevel@tonic-gate * when searching for files. By using ld.so.1's we are defaulting to 19697c478bd9Sstevel@tonic-gate * ELF look-up rules. 19707c478bd9Sstevel@tonic-gate * 19717c478bd9Sstevel@tonic-gate * Note: This case happens when loading the first object onto 19727c478bd9Sstevel@tonic-gate * the plt_tracing link-map. 19737c478bd9Sstevel@tonic-gate */ 19747c478bd9Sstevel@tonic-gate if (clmp == 0) 19757c478bd9Sstevel@tonic-gate clmp = lml_rtld.lm_head; 19767c478bd9Sstevel@tonic-gate 19777c478bd9Sstevel@tonic-gate /* 19787c478bd9Sstevel@tonic-gate * If this path resulted from a $HWCAP specification, then the best 19797c478bd9Sstevel@tonic-gate * hardware capability object has already been establish, and is 19807c478bd9Sstevel@tonic-gate * available in the calling file descriptor. Perform some minor book- 19817c478bd9Sstevel@tonic-gate * keeping so that we can fall through into common code. 19827c478bd9Sstevel@tonic-gate */ 19837c478bd9Sstevel@tonic-gate if (flags & FLG_RT_HWCAP) { 19847c478bd9Sstevel@tonic-gate /* 1985fb1354edSrie * If this object is already loaded, we're done. 19867c478bd9Sstevel@tonic-gate */ 198756deab07SRod Evans if (fdp->fd_lmp) 198856deab07SRod Evans return (fdp->fd_lmp); 19897c478bd9Sstevel@tonic-gate 19907c478bd9Sstevel@tonic-gate /* 19917c478bd9Sstevel@tonic-gate * Obtain the avl index for this object. 19927c478bd9Sstevel@tonic-gate */ 199356deab07SRod Evans (void) fpavl_recorded(lml, fdp->fd_nname, 0, 199456deab07SRod Evans &(fdp->fd_avlwhere)); 1995bbf522bdSrie 199656deab07SRod Evans } else if (fdp->fd_flags & FLG_FD_SLASH) { 19977c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 19987c478bd9Sstevel@tonic-gate 199956deab07SRod Evans if (find_path(lml, clmp, flags, fdp, &_rej, in_nfavl) == 0) { 200031fdd7caSab196087 rejection_inherit(rej, &_rej); 200137ffaf83SRod Evans return (NULL); 20027c478bd9Sstevel@tonic-gate } 20037c478bd9Sstevel@tonic-gate 20047c478bd9Sstevel@tonic-gate /* 20057c478bd9Sstevel@tonic-gate * If this object is already loaded, we're done. 20067c478bd9Sstevel@tonic-gate */ 200756deab07SRod Evans if (fdp->fd_lmp) 200856deab07SRod Evans return (fdp->fd_lmp); 20097c478bd9Sstevel@tonic-gate 20107c478bd9Sstevel@tonic-gate } else { 20117c478bd9Sstevel@tonic-gate /* 20127c478bd9Sstevel@tonic-gate * No '/' - for each directory on list, make a pathname using 20137c478bd9Sstevel@tonic-gate * that directory and filename and try to open that file. 20147c478bd9Sstevel@tonic-gate */ 201556deab07SRod Evans Spath_desc sd = { search_rules, NULL, 0 }; 20167c478bd9Sstevel@tonic-gate Word strhash = 0; 201756deab07SRod Evans int found = 0; 201856deab07SRod Evans 20195aefb655Srie DBG_CALL(Dbg_libs_find(lml, oname)); 20207c478bd9Sstevel@tonic-gate 20217c478bd9Sstevel@tonic-gate /* 202256deab07SRod Evans * Traverse the search path lists, creating full pathnames and 202356deab07SRod Evans * attempt to load each path. 20247c478bd9Sstevel@tonic-gate */ 202556deab07SRod Evans for (pdp = get_next_dir(&sd, clmp, flags); pdp; 202656deab07SRod Evans pdp = get_next_dir(&sd, clmp, flags)) { 20277c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 202856deab07SRod Evans Fdesc fd = { 0 }; 20297c478bd9Sstevel@tonic-gate 20307c478bd9Sstevel@tonic-gate /* 20319aa23310Srie * Under debugging, duplicate path name entries are 20329aa23310Srie * tagged but remain part of the search path list so 20339aa23310Srie * that they can be diagnosed under "unused" processing. 20349aa23310Srie * Skip these entries, as this path would have already 20359aa23310Srie * been attempted. 20369aa23310Srie */ 203756deab07SRod Evans if (pdp->pd_flags & PD_FLG_DUPLICAT) 20389aa23310Srie continue; 20399aa23310Srie 204056deab07SRod Evans fd = *fdp; 204156deab07SRod Evans 20429aa23310Srie /* 20437c478bd9Sstevel@tonic-gate * Try and locate this file. Make sure to clean up 20447c478bd9Sstevel@tonic-gate * any rejection information should the file have 20457c478bd9Sstevel@tonic-gate * been found, but not appropriate. 20467c478bd9Sstevel@tonic-gate */ 204756deab07SRod Evans if (find_file(lml, clmp, flags, &fd, &_rej, pdp, 204856deab07SRod Evans &strhash, in_nfavl) == 0) { 204931fdd7caSab196087 rejection_inherit(rej, &_rej); 20507c478bd9Sstevel@tonic-gate continue; 20517c478bd9Sstevel@tonic-gate } 20527c478bd9Sstevel@tonic-gate 20537c478bd9Sstevel@tonic-gate /* 20549aa23310Srie * Indicate that this search path has been used. If 20559aa23310Srie * this is an LD_LIBRARY_PATH setting, ignore any use 20569aa23310Srie * by ld.so.1 itself. 20579aa23310Srie */ 205856deab07SRod Evans if (((pdp->pd_flags & LA_SER_LIBPATH) == 0) || 20599aa23310Srie ((lml->lm_flags & LML_FLG_RTLDLM) == 0)) 206056deab07SRod Evans pdp->pd_flags |= PD_FLG_USED; 20619aa23310Srie 20629aa23310Srie /* 20637c478bd9Sstevel@tonic-gate * If this object is already loaded, we're done. 20647c478bd9Sstevel@tonic-gate */ 206556deab07SRod Evans *fdp = fd; 206656deab07SRod Evans if (fdp->fd_lmp) 206756deab07SRod Evans return (fdp->fd_lmp); 20687c478bd9Sstevel@tonic-gate 206956deab07SRod Evans fdp->fd_odir = pdp->pd_pname; 207056deab07SRod Evans found = 1; 20717c478bd9Sstevel@tonic-gate break; 20727c478bd9Sstevel@tonic-gate } 20737c478bd9Sstevel@tonic-gate 20747c478bd9Sstevel@tonic-gate /* 20757c478bd9Sstevel@tonic-gate * If the file couldn't be loaded, do another comparison of 20767c478bd9Sstevel@tonic-gate * loaded files using just the basename. This catches folks 20777c478bd9Sstevel@tonic-gate * who may have loaded multiple full pathname files (possibly 20787c478bd9Sstevel@tonic-gate * from setxid applications) to satisfy dependency relationships 20797c478bd9Sstevel@tonic-gate * (i.e., a file might have a dependency on foo.so.1 which has 20807c478bd9Sstevel@tonic-gate * already been opened using its full pathname). 20817c478bd9Sstevel@tonic-gate */ 208256deab07SRod Evans if (found == 0) 20839aa23310Srie return (is_so_loaded(lml, oname, in_nfavl)); 20847c478bd9Sstevel@tonic-gate } 20857c478bd9Sstevel@tonic-gate 20867c478bd9Sstevel@tonic-gate /* 20877c478bd9Sstevel@tonic-gate * Finish mapping the file and return the link-map descriptor. Note, 20887c478bd9Sstevel@tonic-gate * if this request originated from a HWCAP request, re-establish the 20897c478bd9Sstevel@tonic-gate * fdesc information. For single paged objects, such as filters, the 20907c478bd9Sstevel@tonic-gate * original mapping may have been sufficient to capture the file, thus 20917c478bd9Sstevel@tonic-gate * this mapping needs to be reset to insure it doesn't mistakenly get 20927c478bd9Sstevel@tonic-gate * unmapped as part of HWCAP cleanup. 20937c478bd9Sstevel@tonic-gate */ 209456deab07SRod Evans return (load_file(lml, lmco, fdp, in_nfavl)); 20957c478bd9Sstevel@tonic-gate } 20967c478bd9Sstevel@tonic-gate 20977c478bd9Sstevel@tonic-gate /* 209856deab07SRod Evans * Trace an attempt to load an object, and seed the originating name. 20997c478bd9Sstevel@tonic-gate */ 210056deab07SRod Evans const char * 210156deab07SRod Evans load_trace(Lm_list *lml, Pdesc *pdp, Rt_map *clmp, Fdesc *fdp) 21027c478bd9Sstevel@tonic-gate { 210356deab07SRod Evans const char *name = pdp->pd_pname; 21047247f888Srie 21057c478bd9Sstevel@tonic-gate /* 21067c478bd9Sstevel@tonic-gate * First generate any ldd(1) diagnostics. 21077c478bd9Sstevel@tonic-gate */ 21087c478bd9Sstevel@tonic-gate if ((lml->lm_flags & (LML_FLG_TRC_VERBOSE | LML_FLG_TRC_SEARCH)) && 21097c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) 21107c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_FIL_FIND), name, NAME(clmp)); 21117c478bd9Sstevel@tonic-gate 21127c478bd9Sstevel@tonic-gate /* 211356deab07SRod Evans * Propagate any knowledge of a slash within the path name. 211456deab07SRod Evans */ 211556deab07SRod Evans if (pdp->pd_flags & PD_FLG_PNSLASH) 211656deab07SRod Evans fdp->fd_flags |= FLG_FD_SLASH; 211756deab07SRod Evans 211856deab07SRod Evans /* 21197c478bd9Sstevel@tonic-gate * If we're being audited tell the audit library of the file we're 21207c478bd9Sstevel@tonic-gate * about to go search for. 21217c478bd9Sstevel@tonic-gate */ 212256deab07SRod Evans if (((lml->lm_tflags | AFLAGS(clmp)) & LML_TFLG_AUD_ACTIVITY) && 21237c478bd9Sstevel@tonic-gate (lml == LIST(clmp))) 21247c478bd9Sstevel@tonic-gate audit_activity(clmp, LA_ACT_ADD); 21257c478bd9Sstevel@tonic-gate 212656deab07SRod Evans if ((lml->lm_tflags | AFLAGS(clmp)) & LML_TFLG_AUD_OBJSEARCH) { 212756deab07SRod Evans char *aname; 21287c478bd9Sstevel@tonic-gate 21297c478bd9Sstevel@tonic-gate /* 21307c478bd9Sstevel@tonic-gate * The auditor can indicate that this object should be ignored. 21317c478bd9Sstevel@tonic-gate */ 213256deab07SRod Evans if ((aname = 213356deab07SRod Evans audit_objsearch(clmp, name, LA_SER_ORIG)) == NULL) { 21347247f888Srie DBG_CALL(Dbg_audit_terminate(lml, name)); 213556deab07SRod Evans return (NULL); 21367c478bd9Sstevel@tonic-gate } 21377c478bd9Sstevel@tonic-gate 21387247f888Srie if (name != aname) { 213956deab07SRod Evans fdp->fd_flags &= ~FLG_FD_SLASH; 214056deab07SRod Evans name = aname; 21417c478bd9Sstevel@tonic-gate } 21427c478bd9Sstevel@tonic-gate } 214356deab07SRod Evans fdp->fd_oname = name; 214456deab07SRod Evans return (name); 21457c478bd9Sstevel@tonic-gate } 21467c478bd9Sstevel@tonic-gate 21477c478bd9Sstevel@tonic-gate /* 21487c478bd9Sstevel@tonic-gate * Having loaded an object and created a link-map to describe it, finish 21497c478bd9Sstevel@tonic-gate * processing this stage, including verifying any versioning requirements, 21507c478bd9Sstevel@tonic-gate * updating the objects mode, creating a handle if necessary, and adding this 21517c478bd9Sstevel@tonic-gate * object to existing handles if required. 21527c478bd9Sstevel@tonic-gate */ 2153390b98b5Srie static int 21547c478bd9Sstevel@tonic-gate load_finish(Lm_list *lml, const char *name, Rt_map *clmp, int nmode, 21557c478bd9Sstevel@tonic-gate uint_t flags, Grp_hdl **hdl, Rt_map *nlmp) 21567c478bd9Sstevel@tonic-gate { 21572017c965SRod Evans Aliste idx1; 2158cce0e03bSab196087 Grp_hdl *ghp; 21597c478bd9Sstevel@tonic-gate int promote; 21602017c965SRod Evans uint_t rdflags; 21617c478bd9Sstevel@tonic-gate 21627c478bd9Sstevel@tonic-gate /* 21632017c965SRod Evans * If this dependency is associated with a required version ensure that 21647c478bd9Sstevel@tonic-gate * the version is present in the loaded file. 21657c478bd9Sstevel@tonic-gate */ 216656deab07SRod Evans if (((rtld_flags & RT_FL_NOVERSION) == 0) && THIS_IS_ELF(clmp) && 216756deab07SRod Evans VERNEED(clmp) && (elf_verify_vers(name, clmp, nlmp) == 0)) 21687c478bd9Sstevel@tonic-gate return (0); 21697c478bd9Sstevel@tonic-gate 21707c478bd9Sstevel@tonic-gate /* 21717c478bd9Sstevel@tonic-gate * If this object has indicated that it should be isolated as a group 21727c478bd9Sstevel@tonic-gate * (DT_FLAGS_1 contains DF_1_GROUP - object was built with -B group), 21737c478bd9Sstevel@tonic-gate * or if the callers direct bindings indicate it should be isolated as 21742017c965SRod Evans * a group (DYNINFO flags contains FLG_DI_GROUP - dependency following 21757c478bd9Sstevel@tonic-gate * -zgroupperm), establish the appropriate mode. 21767c478bd9Sstevel@tonic-gate * 21777c478bd9Sstevel@tonic-gate * The intent of an object defining itself as a group is to isolate the 21787c478bd9Sstevel@tonic-gate * relocation of the group within its own members, however, unless 21797c478bd9Sstevel@tonic-gate * opened through dlopen(), in which case we assume dlsym() will be used 21802017c965SRod Evans * to locate symbols in the new object, we still need to associate the 21812017c965SRod Evans * new object with the caller so that the caller can bind to this new 21822017c965SRod Evans * object. This is equivalent to a dlopen(RTLD_GROUP) and dlsym() 21832017c965SRod Evans * using the returned handle. 21847c478bd9Sstevel@tonic-gate */ 21857c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) | flags) & FLG_RT_SETGROUP) { 21867c478bd9Sstevel@tonic-gate nmode &= ~RTLD_WORLD; 21877c478bd9Sstevel@tonic-gate nmode |= RTLD_GROUP; 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate /* 21902017c965SRod Evans * If the object wasn't explicitly dlopen()'ed, in which case a 21912017c965SRod Evans * handle would have been requested, associate the object with 21927c478bd9Sstevel@tonic-gate * the parent. 21937c478bd9Sstevel@tonic-gate */ 21942017c965SRod Evans if ((flags & FLG_RT_PUBHDL) == 0) 21957c478bd9Sstevel@tonic-gate nmode |= RTLD_PARENT; 21967c478bd9Sstevel@tonic-gate } 21977c478bd9Sstevel@tonic-gate 21987c478bd9Sstevel@tonic-gate /* 21997c478bd9Sstevel@tonic-gate * Establish new mode and flags. 22007c478bd9Sstevel@tonic-gate */ 22017c478bd9Sstevel@tonic-gate promote = update_mode(nlmp, MODE(nlmp), nmode); 22027c478bd9Sstevel@tonic-gate FLAGS(nlmp) |= flags; 22037c478bd9Sstevel@tonic-gate 22047c478bd9Sstevel@tonic-gate /* 22052017c965SRod Evans * Establish the flags for any referenced dependency descriptors 22062017c965SRod Evans * (Grp_desc). 22072017c965SRod Evans * 22082017c965SRod Evans * - The referenced object is available for dlsym(). 22092017c965SRod Evans * - The referenced object is available to relocate against. 22102017c965SRod Evans * - The referenced object should have it's dependencies 22112017c965SRod Evans * added to this handle 22122017c965SRod Evans */ 22132017c965SRod Evans rdflags = (GPD_DLSYM | GPD_RELOC | GPD_ADDEPS); 22142017c965SRod Evans 22152017c965SRod Evans /* 22167c478bd9Sstevel@tonic-gate * If we've been asked to establish a handle create one for this object. 22177c478bd9Sstevel@tonic-gate * Or, if this object has already been analyzed, but this reference 22182017c965SRod Evans * requires that the mode of the object be promoted, create a private 22197c478bd9Sstevel@tonic-gate * handle to propagate the new modes to all this objects dependencies. 22207c478bd9Sstevel@tonic-gate */ 22212017c965SRod Evans if ((FLAGS(nlmp) & (FLG_RT_PUBHDL | FLG_RT_PRIHDL)) || 22222017c965SRod Evans (promote && (FLAGS(nlmp) & FLG_RT_ANALYZED))) { 22232017c965SRod Evans uint_t oflags, hflags, cdflags = 0; 22247c478bd9Sstevel@tonic-gate 22258af2c5b9Srie /* 22268af2c5b9Srie * Establish any flags for the handle (Grp_hdl). 22278af2c5b9Srie * 22282017c965SRod Evans * - Public handles establish dependencies between objects 22292017c965SRod Evans * that must be taken into account when dlclose()'ing 22302017c965SRod Evans * objects. Private handles provide for collecting 22312017c965SRod Evans * dependencies, but do not affect dlclose(). Note that 22322017c965SRod Evans * a handle may already exist, but the public/private 22332017c965SRod Evans * state is set to trigger the required propagation of the 22342017c965SRod Evans * handle's flags and any dependency gathering. 22352017c965SRod Evans * - Use of the RTLD_FIRST flag indicates that only the first 22368af2c5b9Srie * dependency on the handle (the new object) can be used 22378af2c5b9Srie * to satisfy dlsym() requests. 22388af2c5b9Srie */ 22392017c965SRod Evans if (FLAGS(nlmp) & FLG_RT_PUBHDL) 22402017c965SRod Evans hflags = GPH_PUBLIC; 22412017c965SRod Evans else 22422017c965SRod Evans hflags = GPH_PRIVATE; 22432017c965SRod Evans 22447c478bd9Sstevel@tonic-gate if (nmode & RTLD_FIRST) 22452017c965SRod Evans hflags |= GPH_FIRST; 22468af2c5b9Srie 22478af2c5b9Srie /* 22488af2c5b9Srie * Establish the flags for this callers dependency descriptor 22498af2c5b9Srie * (Grp_desc). 22508af2c5b9Srie * 22512017c965SRod Evans * - The creation of a public handle creates a descriptor 22522017c965SRod Evans * for the referenced object and the caller (parent). 22538af2c5b9Srie * Typically, the handle is created for dlopen() or for 22542017c965SRod Evans * filtering. A private handle does not need to maintain 22552017c965SRod Evans * a descriptor to the parent. 22562017c965SRod Evans * - Use of the RTLD_PARENT flag indicates that the parent 22578af2c5b9Srie * can be relocated against. 22588af2c5b9Srie */ 22592017c965SRod Evans if (FLAGS(nlmp) & FLG_RT_PUBHDL) { 22602017c965SRod Evans cdflags |= GPD_PARENT; 22618af2c5b9Srie if (nmode & RTLD_PARENT) 22628af2c5b9Srie cdflags |= GPD_RELOC; 22632017c965SRod Evans } 22647c478bd9Sstevel@tonic-gate 22657c478bd9Sstevel@tonic-gate /* 22662017c965SRod Evans * Now that the handle flags have been established, remove any 22672017c965SRod Evans * handle definition from the referenced object so that the 22682017c965SRod Evans * definitions don't mistakenly get inherited by a dependency. 22697c478bd9Sstevel@tonic-gate */ 22707c478bd9Sstevel@tonic-gate oflags = FLAGS(nlmp); 22712017c965SRod Evans FLAGS(nlmp) &= ~(FLG_RT_PUBHDL | FLG_RT_PRIHDL); 22727c478bd9Sstevel@tonic-gate 22738af2c5b9Srie DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD)); 22742017c965SRod Evans if ((ghp = hdl_create(lml, nlmp, clmp, hflags, rdflags, 22752017c965SRod Evans cdflags)) == NULL) 22767c478bd9Sstevel@tonic-gate return (0); 22777c478bd9Sstevel@tonic-gate 22787c478bd9Sstevel@tonic-gate /* 22797c478bd9Sstevel@tonic-gate * Add any dependencies that are already loaded, to the handle. 22807c478bd9Sstevel@tonic-gate */ 228102ca3e02Srie if (hdl_initialize(ghp, nlmp, nmode, promote) == 0) 22827c478bd9Sstevel@tonic-gate return (0); 22837c478bd9Sstevel@tonic-gate 22847c478bd9Sstevel@tonic-gate if (hdl) 22857c478bd9Sstevel@tonic-gate *hdl = ghp; 22867c478bd9Sstevel@tonic-gate 22877c478bd9Sstevel@tonic-gate /* 22882017c965SRod Evans * If we were asked to create a public handle, we're done. 22898af2c5b9Srie * 22902017c965SRod Evans * If this is a private handle request, then the handle is left 22912017c965SRod Evans * intact with a GPH_PRIVATE identifier. This handle is a 22922017c965SRod Evans * convenience for processing the dependencies of this object, 22932017c965SRod Evans * but does not affect how this object might be dlclose()'d. 22942017c965SRod Evans * For a private handle, fall through to carry out any group 22952017c965SRod Evans * processing. 22968af2c5b9Srie */ 22972017c965SRod Evans if (oflags & FLG_RT_PUBHDL) 22982017c965SRod Evans return (1); 22997c478bd9Sstevel@tonic-gate } 23007c478bd9Sstevel@tonic-gate 23017c478bd9Sstevel@tonic-gate /* 23027c478bd9Sstevel@tonic-gate * If the caller isn't part of a group we're done. 23037c478bd9Sstevel@tonic-gate */ 2304cce0e03bSab196087 if (GROUPS(clmp) == NULL) 23057c478bd9Sstevel@tonic-gate return (1); 23067c478bd9Sstevel@tonic-gate 23077c478bd9Sstevel@tonic-gate /* 23087c478bd9Sstevel@tonic-gate * Determine if our caller is already associated with a handle, if so 23097c478bd9Sstevel@tonic-gate * we need to add this object to any handles that already exist. 23107c478bd9Sstevel@tonic-gate * Traverse the list of groups our caller is a member of and add this 23117c478bd9Sstevel@tonic-gate * new link-map to those groups. 23127c478bd9Sstevel@tonic-gate */ 23132017c965SRod Evans for (APLIST_TRAVERSE(GROUPS(clmp), idx1, ghp)) { 23142017c965SRod Evans Aliste idx2; 23157c478bd9Sstevel@tonic-gate Grp_desc *gdp; 23162017c965SRod Evans int ale; 2317cce0e03bSab196087 Rt_map *dlmp1; 2318cce0e03bSab196087 APlist *lmalp = NULL; 23197c478bd9Sstevel@tonic-gate 23202017c965SRod Evans DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD)); 23212017c965SRod Evans 23227c478bd9Sstevel@tonic-gate /* 23237c478bd9Sstevel@tonic-gate * If the caller doesn't indicate that its dependencies should 23247c478bd9Sstevel@tonic-gate * be added to a handle, ignore it. This case identifies a 23257c478bd9Sstevel@tonic-gate * parent of a dlopen(RTLD_PARENT) request. 23267c478bd9Sstevel@tonic-gate */ 23272017c965SRod Evans for (ALIST_TRAVERSE(ghp->gh_depends, idx2, gdp)) { 23287c478bd9Sstevel@tonic-gate if (gdp->gd_depend == clmp) 23297c478bd9Sstevel@tonic-gate break; 23307c478bd9Sstevel@tonic-gate } 23317c478bd9Sstevel@tonic-gate if ((gdp->gd_flags & GPD_ADDEPS) == 0) 23327c478bd9Sstevel@tonic-gate continue; 23337c478bd9Sstevel@tonic-gate 23342017c965SRod Evans if ((gdp = hdl_add(ghp, nlmp, rdflags, &ale)) == NULL) 23357c478bd9Sstevel@tonic-gate return (0); 23367c478bd9Sstevel@tonic-gate 23377c478bd9Sstevel@tonic-gate /* 23387c478bd9Sstevel@tonic-gate * If this member already exists then its dependencies will 23397c478bd9Sstevel@tonic-gate * have already been processed. 23407c478bd9Sstevel@tonic-gate */ 23412017c965SRod Evans if (ale == ALE_EXISTS) 23427c478bd9Sstevel@tonic-gate continue; 23437c478bd9Sstevel@tonic-gate 23447c478bd9Sstevel@tonic-gate /* 23457c478bd9Sstevel@tonic-gate * If the object we've added has just been opened, it will not 23467c478bd9Sstevel@tonic-gate * yet have been processed for its dependencies, these will be 23477c478bd9Sstevel@tonic-gate * added on later calls to load_one(). If it doesn't have any 23487c478bd9Sstevel@tonic-gate * dependencies we're also done. 23497c478bd9Sstevel@tonic-gate */ 23507c478bd9Sstevel@tonic-gate if (((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0) || 2351cce0e03bSab196087 (DEPENDS(nlmp) == NULL)) 23527c478bd9Sstevel@tonic-gate continue; 23537c478bd9Sstevel@tonic-gate 23547c478bd9Sstevel@tonic-gate /* 23557c478bd9Sstevel@tonic-gate * Otherwise, this object exists and has dependencies, so add 23567c478bd9Sstevel@tonic-gate * all of its dependencies to the handle were operating on. 23577c478bd9Sstevel@tonic-gate */ 235856deab07SRod Evans if (aplist_append(&lmalp, nlmp, AL_CNT_DEPCLCT) == NULL) 23597c478bd9Sstevel@tonic-gate return (0); 23607c478bd9Sstevel@tonic-gate 23612017c965SRod Evans for (APLIST_TRAVERSE(lmalp, idx2, dlmp1)) { 23622017c965SRod Evans Aliste idx3; 2363cce0e03bSab196087 Bnd_desc *bdp; 23647c478bd9Sstevel@tonic-gate 23657c478bd9Sstevel@tonic-gate /* 23667c478bd9Sstevel@tonic-gate * Add any dependencies of this dependency to the 23677c478bd9Sstevel@tonic-gate * dynamic dependency list so they can be further 23687c478bd9Sstevel@tonic-gate * processed. 23697c478bd9Sstevel@tonic-gate */ 23702017c965SRod Evans for (APLIST_TRAVERSE(DEPENDS(dlmp1), idx3, bdp)) { 23717c478bd9Sstevel@tonic-gate Rt_map *dlmp2 = bdp->b_depend; 23727c478bd9Sstevel@tonic-gate 23737c478bd9Sstevel@tonic-gate if ((bdp->b_flags & BND_NEEDED) == 0) 23747c478bd9Sstevel@tonic-gate continue; 23757c478bd9Sstevel@tonic-gate 2376cce0e03bSab196087 if (aplist_test(&lmalp, dlmp2, 23777c478bd9Sstevel@tonic-gate AL_CNT_DEPCLCT) == 0) { 23787c478bd9Sstevel@tonic-gate free(lmalp); 23797c478bd9Sstevel@tonic-gate return (0); 23807c478bd9Sstevel@tonic-gate } 23817c478bd9Sstevel@tonic-gate } 23827c478bd9Sstevel@tonic-gate 23837c478bd9Sstevel@tonic-gate if (nlmp == dlmp1) 23847c478bd9Sstevel@tonic-gate continue; 23857c478bd9Sstevel@tonic-gate 23862017c965SRod Evans if ((gdp = 23872017c965SRod Evans hdl_add(ghp, dlmp1, rdflags, &ale)) == NULL) { 23887c478bd9Sstevel@tonic-gate free(lmalp); 23897c478bd9Sstevel@tonic-gate return (0); 23907c478bd9Sstevel@tonic-gate } 239156deab07SRod Evans 2392*e0e63816SRod Evans if (ale == ALE_CREATE) 2393*e0e63816SRod Evans (void) update_mode(dlmp1, MODE(dlmp1), nmode); 239456deab07SRod Evans } 23957c478bd9Sstevel@tonic-gate free(lmalp); 23967c478bd9Sstevel@tonic-gate } 23977c478bd9Sstevel@tonic-gate return (1); 23987c478bd9Sstevel@tonic-gate } 23997c478bd9Sstevel@tonic-gate 24007c478bd9Sstevel@tonic-gate /* 24017c478bd9Sstevel@tonic-gate * The central routine for loading shared objects. Insures ldd() diagnostics, 24027c478bd9Sstevel@tonic-gate * handles and any other related additions are all done in one place. 24037c478bd9Sstevel@tonic-gate */ 240456deab07SRod Evans Rt_map * 240556deab07SRod Evans load_path(Lm_list *lml, Aliste lmco, Rt_map *clmp, int nmode, uint_t flags, 240656deab07SRod Evans Grp_hdl **hdl, Fdesc *fdp, Rej_desc *rej, int *in_nfavl) 24077c478bd9Sstevel@tonic-gate { 240856deab07SRod Evans const char *name = fdp->fd_oname; 24097c478bd9Sstevel@tonic-gate Rt_map *nlmp; 24107c478bd9Sstevel@tonic-gate 24117c478bd9Sstevel@tonic-gate if ((nmode & RTLD_NOLOAD) == 0) { 2412*e0e63816SRod Evans int oin_nfavl; 2413*e0e63816SRod Evans 2414*e0e63816SRod Evans /* 2415*e0e63816SRod Evans * Keep track of the number of not-found loads. 2416*e0e63816SRod Evans */ 2417*e0e63816SRod Evans if (in_nfavl) 2418*e0e63816SRod Evans oin_nfavl = *in_nfavl; 2419*e0e63816SRod Evans 24207c478bd9Sstevel@tonic-gate /* 24217c478bd9Sstevel@tonic-gate * If this isn't a noload request attempt to load the file. 24227c478bd9Sstevel@tonic-gate */ 242356deab07SRod Evans if ((nlmp = load_so(lml, lmco, clmp, flags, fdp, rej, 242456deab07SRod Evans in_nfavl)) == NULL) 242537ffaf83SRod Evans return (NULL); 24267c478bd9Sstevel@tonic-gate 24277c478bd9Sstevel@tonic-gate /* 2428*e0e63816SRod Evans * If this file has been found, reset the not-found load count. 2429*e0e63816SRod Evans * Although a search for this file might have inspected a number 2430*e0e63816SRod Evans * of non-existent path names, the file has been found so there 2431*e0e63816SRod Evans * is no need to to accumulate a non-found count, as this may 2432*e0e63816SRod Evans * trigger unnecessary fall back (retry) processing. 2433*e0e63816SRod Evans */ 2434*e0e63816SRod Evans if (in_nfavl) 2435*e0e63816SRod Evans *in_nfavl = oin_nfavl; 2436*e0e63816SRod Evans 2437*e0e63816SRod Evans /* 24387c478bd9Sstevel@tonic-gate * If we've loaded a library which identifies itself as not 24397c478bd9Sstevel@tonic-gate * being dlopen()'able catch it here. Let non-dlopen()'able 24407c478bd9Sstevel@tonic-gate * objects through under RTLD_CONFGEN as they're only being 24417c478bd9Sstevel@tonic-gate * mapped to be dldump()'ed. 24427c478bd9Sstevel@tonic-gate */ 24437c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_APPLIC) && ((FLAGS(nlmp) & 24447c478bd9Sstevel@tonic-gate (FLG_RT_NOOPEN | FLG_RT_RELOCED)) == FLG_RT_NOOPEN) && 24457c478bd9Sstevel@tonic-gate ((nmode & RTLD_CONFGEN) == 0)) { 24467c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 24477c478bd9Sstevel@tonic-gate 24487c478bd9Sstevel@tonic-gate _rej.rej_name = name; 24497c478bd9Sstevel@tonic-gate _rej.rej_type = SGS_REJ_STR; 24507c478bd9Sstevel@tonic-gate _rej.rej_str = MSG_INTL(MSG_GEN_NOOPEN); 2451ba2be530Sab196087 DBG_CALL(Dbg_file_rejected(lml, &_rej, M_MACH)); 245231fdd7caSab196087 rejection_inherit(rej, &_rej); 24537c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 245437ffaf83SRod Evans return (NULL); 24557c478bd9Sstevel@tonic-gate } 24567c478bd9Sstevel@tonic-gate } else { 24577c478bd9Sstevel@tonic-gate /* 24587c478bd9Sstevel@tonic-gate * If it's a NOLOAD request - check to see if the object 24597c478bd9Sstevel@tonic-gate * has already been loaded. 24607c478bd9Sstevel@tonic-gate */ 24617c478bd9Sstevel@tonic-gate /* LINTED */ 24629aa23310Srie if (nlmp = is_so_loaded(lml, name, in_nfavl)) { 24637c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_TRC_VERBOSE) && 24647c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) { 24657c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_FIL_FIND), name, 24667c478bd9Sstevel@tonic-gate NAME(clmp)); 24677247f888Srie /* BEGIN CSTYLED */ 24687c478bd9Sstevel@tonic-gate if (*name == '/') 24697c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), 24707c478bd9Sstevel@tonic-gate name, MSG_ORIG(MSG_STR_EMPTY), 24717c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 24727c478bd9Sstevel@tonic-gate else 24737c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), 24747c478bd9Sstevel@tonic-gate name, NAME(nlmp), 24757c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY), 24767c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 24777247f888Srie /* END CSTYLED */ 24787c478bd9Sstevel@tonic-gate } 24797c478bd9Sstevel@tonic-gate } else { 24807c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 24817c478bd9Sstevel@tonic-gate 24827c478bd9Sstevel@tonic-gate _rej.rej_name = name; 24837c478bd9Sstevel@tonic-gate _rej.rej_type = SGS_REJ_STR; 24847c478bd9Sstevel@tonic-gate _rej.rej_str = strerror(ENOENT); 2485ba2be530Sab196087 DBG_CALL(Dbg_file_rejected(lml, &_rej, M_MACH)); 248631fdd7caSab196087 rejection_inherit(rej, &_rej); 248737ffaf83SRod Evans return (NULL); 24887c478bd9Sstevel@tonic-gate } 24897c478bd9Sstevel@tonic-gate } 24907c478bd9Sstevel@tonic-gate 24917c478bd9Sstevel@tonic-gate /* 24927c478bd9Sstevel@tonic-gate * Finish processing this loaded object. 24937c478bd9Sstevel@tonic-gate */ 2494390b98b5Srie if (load_finish(lml, name, clmp, nmode, flags, hdl, nlmp) == 0) { 2495390b98b5Srie FLAGS(nlmp) &= ~FLG_RT_NEWLOAD; 24967c478bd9Sstevel@tonic-gate 24977c478bd9Sstevel@tonic-gate /* 2498390b98b5Srie * If this object has already been analyzed, then it is in use, 2499390b98b5Srie * so even though this operation has failed, it should not be 2500390b98b5Srie * torn down. 25017c478bd9Sstevel@tonic-gate */ 25027c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0) 25037c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 250437ffaf83SRod Evans return (NULL); 25057c478bd9Sstevel@tonic-gate } 25067c478bd9Sstevel@tonic-gate 25077c478bd9Sstevel@tonic-gate /* 2508390b98b5Srie * If this object is new, and we're being audited, tell the audit 2509390b98b5Srie * library of the file we've just opened. Note, if the new link-map 2510390b98b5Srie * requires local auditing of its dependencies we also register its 2511390b98b5Srie * opening. 2512390b98b5Srie */ 2513390b98b5Srie if (FLAGS(nlmp) & FLG_RT_NEWLOAD) { 2514390b98b5Srie FLAGS(nlmp) &= ~FLG_RT_NEWLOAD; 2515390b98b5Srie 251656deab07SRod Evans if (((lml->lm_tflags | AFLAGS(clmp) | AFLAGS(nlmp)) & 2517390b98b5Srie LML_TFLG_AUD_MASK) && (((lml->lm_flags | 2518390b98b5Srie LIST(clmp)->lm_flags) & LML_FLG_NOAUDIT) == 0)) { 2519390b98b5Srie if (audit_objopen(clmp, nlmp) == 0) { 2520390b98b5Srie remove_so(lml, nlmp); 252137ffaf83SRod Evans return (NULL); 2522390b98b5Srie } 2523390b98b5Srie } 2524390b98b5Srie } 2525390b98b5Srie return (nlmp); 2526390b98b5Srie } 2527390b98b5Srie 2528390b98b5Srie /* 25297c478bd9Sstevel@tonic-gate * Load one object from a possible list of objects. Typically, for requests 25307c478bd9Sstevel@tonic-gate * such as NEEDED's, only one object is specified. However, this object could 25317c478bd9Sstevel@tonic-gate * be specified using $ISALIST or $HWCAP, in which case only the first object 25327c478bd9Sstevel@tonic-gate * that can be loaded is used (ie. the best). 25337c478bd9Sstevel@tonic-gate */ 25347c478bd9Sstevel@tonic-gate Rt_map * 253556deab07SRod Evans load_one(Lm_list *lml, Aliste lmco, Alist *palp, Rt_map *clmp, int mode, 25369aa23310Srie uint_t flags, Grp_hdl **hdl, int *in_nfavl) 25377c478bd9Sstevel@tonic-gate { 25387c478bd9Sstevel@tonic-gate Rej_desc rej = { 0 }; 253956deab07SRod Evans Aliste idx; 254056deab07SRod Evans Pdesc *pdp; 25417c478bd9Sstevel@tonic-gate const char *name; 25427c478bd9Sstevel@tonic-gate 254356deab07SRod Evans for (ALIST_TRAVERSE(palp, idx, pdp)) { 254456deab07SRod Evans Rt_map *lmp = NULL; 25457247f888Srie 25467c478bd9Sstevel@tonic-gate /* 25477c478bd9Sstevel@tonic-gate * A Hardware capabilities requirement can itself expand into 25487c478bd9Sstevel@tonic-gate * a number of candidates. 25497c478bd9Sstevel@tonic-gate */ 255056deab07SRod Evans if (pdp->pd_flags & PD_TKN_HWCAP) { 255156deab07SRod Evans lmp = load_hwcap(lml, lmco, pdp->pd_pname, clmp, 255256deab07SRod Evans mode, (flags | FLG_RT_HWCAP), hdl, &rej, in_nfavl); 25537c478bd9Sstevel@tonic-gate } else { 255456deab07SRod Evans Fdesc fd = { 0 }; 255556deab07SRod Evans 255656deab07SRod Evans /* 255756deab07SRod Evans * Trace the inspection of this file, determine any 255856deab07SRod Evans * auditor substitution, and seed the file descriptor 255956deab07SRod Evans * with the originating name. 256056deab07SRod Evans */ 256156deab07SRod Evans if (load_trace(lml, pdp, clmp, &fd) == NULL) 256256deab07SRod Evans continue; 256356deab07SRod Evans 256456deab07SRod Evans /* 256556deab07SRod Evans * Locate and load the file. 256656deab07SRod Evans */ 256756deab07SRod Evans lmp = load_path(lml, lmco, clmp, mode, flags, hdl, &fd, 256856deab07SRod Evans &rej, in_nfavl); 25697c478bd9Sstevel@tonic-gate } 257056deab07SRod Evans if (lmp) 257156deab07SRod Evans return (lmp); 25727c478bd9Sstevel@tonic-gate } 25737c478bd9Sstevel@tonic-gate 25747c478bd9Sstevel@tonic-gate /* 257556deab07SRod Evans * If no objects can be found, use the first path name from the Alist 257656deab07SRod Evans * to provide a diagnostic. If this pathname originated from an 257756deab07SRod Evans * expanded token, use the original name for any diagnostic output. 25787c478bd9Sstevel@tonic-gate */ 257956deab07SRod Evans pdp = alist_item(palp, 0); 258056deab07SRod Evans 258156deab07SRod Evans if ((name = pdp->pd_oname) == 0) 258256deab07SRod Evans name = pdp->pd_pname; 25837c478bd9Sstevel@tonic-gate 25847c478bd9Sstevel@tonic-gate file_notfound(lml, name, clmp, flags, &rej); 258537ffaf83SRod Evans return (NULL); 25867c478bd9Sstevel@tonic-gate } 25877c478bd9Sstevel@tonic-gate 25887c478bd9Sstevel@tonic-gate /* 25899a411307Srie * Determine whether a symbol is defined as an interposer. 25909a411307Srie */ 25919a411307Srie int 25929a411307Srie is_sym_interposer(Rt_map *lmp, Sym *sym) 25939a411307Srie { 25949a411307Srie Syminfo *sip = SYMINFO(lmp); 25959a411307Srie 25969a411307Srie if (sip) { 25979a411307Srie ulong_t ndx; 25989a411307Srie 25999a411307Srie ndx = (((ulong_t)sym - (ulong_t)SYMTAB(lmp)) / SYMENT(lmp)); 26009a411307Srie /* LINTED */ 26019a411307Srie sip = (Syminfo *)((char *)sip + (ndx * SYMINENT(lmp))); 26029a411307Srie if (sip->si_flags & SYMINFO_FLG_INTERPOSE) 26039a411307Srie return (1); 26049a411307Srie } 26059a411307Srie return (0); 26069a411307Srie } 26079a411307Srie 26089a411307Srie /* 26097c478bd9Sstevel@tonic-gate * While processing direct or group bindings, determine whether the object to 26107c478bd9Sstevel@tonic-gate * which we've bound can be interposed upon. In this context, copy relocations 26117c478bd9Sstevel@tonic-gate * are a form of interposition. 26127c478bd9Sstevel@tonic-gate */ 26137c478bd9Sstevel@tonic-gate static Sym * 2614adbfe822Srie lookup_sym_interpose(Slookup *slp, Rt_map **dlmp, uint_t *binfo, Sym *osym, 2615adbfe822Srie int *in_nfavl) 26167c478bd9Sstevel@tonic-gate { 2617adbfe822Srie Rt_map *lmp, *clmp; 26187c478bd9Sstevel@tonic-gate Slookup sl; 2619adbfe822Srie Lm_list *lml; 26207c478bd9Sstevel@tonic-gate 26217c478bd9Sstevel@tonic-gate /* 26227c478bd9Sstevel@tonic-gate * If we've bound to a copy relocation definition then we need to assign 26237c478bd9Sstevel@tonic-gate * this binding to the original copy reference. Fabricate an inter- 26247c478bd9Sstevel@tonic-gate * position diagnostic, as this is a legitimate form of interposition. 26257c478bd9Sstevel@tonic-gate */ 2626adbfe822Srie if (osym && (FLAGS1(*dlmp) & FL1_RT_COPYTOOK)) { 26277c478bd9Sstevel@tonic-gate Rel_copy *rcp; 2628cce0e03bSab196087 Aliste idx; 26297c478bd9Sstevel@tonic-gate 2630cce0e03bSab196087 for (ALIST_TRAVERSE(COPY_R(*dlmp), idx, rcp)) { 2631aa736cbeSrie if ((osym == rcp->r_dsym) || (osym->st_value && 2632aa736cbeSrie (osym->st_value == rcp->r_dsym->st_value))) { 26337c478bd9Sstevel@tonic-gate *dlmp = rcp->r_rlmp; 26347c478bd9Sstevel@tonic-gate *binfo |= 26357c478bd9Sstevel@tonic-gate (DBG_BINFO_INTERPOSE | DBG_BINFO_COPYREF); 26367c478bd9Sstevel@tonic-gate return (rcp->r_rsym); 26377c478bd9Sstevel@tonic-gate } 26387c478bd9Sstevel@tonic-gate } 26397c478bd9Sstevel@tonic-gate } 26407c478bd9Sstevel@tonic-gate 2641aa736cbeSrie /* 2642adbfe822Srie * If a symbol binding has been established, inspect the link-map list 2643adbfe822Srie * of the destination object, otherwise use the link-map list of the 2644adbfe822Srie * original caller. 2645adbfe822Srie */ 2646adbfe822Srie if (osym) 2647adbfe822Srie clmp = *dlmp; 2648adbfe822Srie else 2649adbfe822Srie clmp = slp->sl_cmap; 2650adbfe822Srie 2651adbfe822Srie lml = LIST(clmp); 2652adbfe822Srie lmp = lml->lm_head; 2653adbfe822Srie 2654adbfe822Srie /* 2655aa736cbeSrie * Prior to Solaris 8, external references from an executable that were 2656aa736cbeSrie * bound to an uninitialized variable (.bss) within a shared object did 2657aa736cbeSrie * not establish a copy relocation. This was thought to be an 2658aa736cbeSrie * optimization, to prevent copying zero's to zero's. Typically, 2659aa736cbeSrie * interposition took its course, with the shared object binding to the 2660aa736cbeSrie * executables data definition. 2661aa736cbeSrie * 2662aa736cbeSrie * This scenario can be broken when this old executable runs against a 2663aa736cbeSrie * new shared object that is directly bound. With no copy-relocation 2664aa736cbeSrie * record, ld.so.1 has no data to trigger the normal vectoring of the 2665aa736cbeSrie * binding to the executable. 2666aa736cbeSrie * 2667aa736cbeSrie * Starting with Solaris 8, a DT_FLAGS entry is written to all objects, 2668aa736cbeSrie * regardless of there being any DF_ flags entries. Therefore, an 2669aa736cbeSrie * object without this dynamic tag is susceptible to the copy relocation 2670aa736cbeSrie * issue. If the executable has no DT_FLAGS tag, and contains the same 2671aa736cbeSrie * .bss symbol definition as has been directly bound to, redirect the 2672aa736cbeSrie * binding to the executables data definition. 2673aa736cbeSrie */ 267456deab07SRod Evans if (osym && ((FLAGS1(lmp) & FL1_RT_DTFLAGS) == 0) && 2675adbfe822Srie (FCT(lmp) == &elf_fct) && 2676466e2a62Srie (ELF_ST_TYPE(osym->st_info) != STT_FUNC) && 2677466e2a62Srie are_bits_zero(*dlmp, osym, 0)) { 2678aa736cbeSrie Rt_map *ilmp; 2679aa736cbeSrie Sym *isym; 2680aa736cbeSrie 2681adbfe822Srie sl = *slp; 2682adbfe822Srie sl.sl_imap = lmp; 2683adbfe822Srie 2684aa736cbeSrie /* 2685aa736cbeSrie * Determine whether the same symbol name exists within the 2686aa736cbeSrie * executable, that the size and type of symbol are the same, 2687aa736cbeSrie * and that the symbol is also associated with .bss. 2688aa736cbeSrie */ 26899aa23310Srie if (((isym = SYMINTP(lmp)(&sl, &ilmp, binfo, 26909aa23310Srie in_nfavl)) != NULL) && (isym->st_size == osym->st_size) && 2691aa736cbeSrie (isym->st_info == osym->st_info) && 2692466e2a62Srie are_bits_zero(lmp, isym, 1)) { 2693aa736cbeSrie *dlmp = lmp; 2694aa736cbeSrie *binfo |= (DBG_BINFO_INTERPOSE | DBG_BINFO_COPYREF); 2695aa736cbeSrie return (isym); 2696aa736cbeSrie } 2697aa736cbeSrie } 2698aa736cbeSrie 26997c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_INTRPOSE) == 0) 270037ffaf83SRod Evans return (NULL); 27017c478bd9Sstevel@tonic-gate 27027c478bd9Sstevel@tonic-gate /* 27037c478bd9Sstevel@tonic-gate * Traverse the list of known interposers to determine whether any 27047c478bd9Sstevel@tonic-gate * offer the same symbol. Note, the head of the link-map could be 2705aa736cbeSrie * identified as an interposer. Otherwise, skip the head of the 2706aa736cbeSrie * link-map, so that we don't bind to any .plt references, or 2707aa736cbeSrie * copy-relocation destinations unintentionally. 27087c478bd9Sstevel@tonic-gate */ 27097c478bd9Sstevel@tonic-gate lmp = lml->lm_head; 27107c478bd9Sstevel@tonic-gate sl = *slp; 2711adbfe822Srie 27129a411307Srie if (((FLAGS(lmp) & MSK_RT_INTPOSE) == 0) || (sl.sl_flags & LKUP_COPY)) 2713cb511613SAli Bahrami lmp = NEXT_RT_MAP(lmp); 27147c478bd9Sstevel@tonic-gate 2715cb511613SAli Bahrami for (; lmp; lmp = NEXT_RT_MAP(lmp)) { 27167c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_DELETE) 27177c478bd9Sstevel@tonic-gate continue; 27189a411307Srie if ((FLAGS(lmp) & MSK_RT_INTPOSE) == 0) 27197c478bd9Sstevel@tonic-gate break; 27207c478bd9Sstevel@tonic-gate 2721*e0e63816SRod Evans /* 2722*e0e63816SRod Evans * If we had already bound to this object, there's no point in 2723*e0e63816SRod Evans * searching it again, we're done. 2724*e0e63816SRod Evans */ 2725*e0e63816SRod Evans if (lmp == *dlmp) 2726*e0e63816SRod Evans break; 2727*e0e63816SRod Evans 2728*e0e63816SRod Evans /* 2729*e0e63816SRod Evans * If this interposer can be inspected by the caller, look for 2730*e0e63816SRod Evans * the symbol within the interposer. 2731*e0e63816SRod Evans */ 2732*e0e63816SRod Evans if (callable(clmp, lmp, 0, sl.sl_flags)) { 27339a411307Srie Rt_map *ilmp; 2734aa736cbeSrie Sym *isym; 27359a411307Srie 27367c478bd9Sstevel@tonic-gate sl.sl_imap = lmp; 27379aa23310Srie if (isym = SYMINTP(lmp)(&sl, &ilmp, binfo, in_nfavl)) { 27389a411307Srie /* 27399a411307Srie * If this object provides individual symbol 27409a411307Srie * interposers, make sure that the symbol we 27419a411307Srie * have found is tagged as an interposer. 27429a411307Srie */ 27439a411307Srie if ((FLAGS(ilmp) & FLG_RT_SYMINTPO) && 2744aa736cbeSrie (is_sym_interposer(ilmp, isym) == 0)) 27459a411307Srie continue; 27469a411307Srie 27479a411307Srie /* 27489a411307Srie * Indicate this binding has occurred to an 27499a411307Srie * interposer, and return the symbol. 27509a411307Srie */ 27517c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_INTERPOSE; 27529a411307Srie *dlmp = ilmp; 2753aa736cbeSrie return (isym); 27547c478bd9Sstevel@tonic-gate } 27557c478bd9Sstevel@tonic-gate } 27567c478bd9Sstevel@tonic-gate } 275737ffaf83SRod Evans return (NULL); 27587c478bd9Sstevel@tonic-gate } 27597c478bd9Sstevel@tonic-gate 27607c478bd9Sstevel@tonic-gate /* 27617c478bd9Sstevel@tonic-gate * If an object specifies direct bindings (it contains a syminfo structure 27627c478bd9Sstevel@tonic-gate * describing where each binding was established during link-editing, and the 27637c478bd9Sstevel@tonic-gate * object was built -Bdirect), then look for the symbol in the specific object. 27647c478bd9Sstevel@tonic-gate */ 27657c478bd9Sstevel@tonic-gate static Sym * 27667c478bd9Sstevel@tonic-gate lookup_sym_direct(Slookup *slp, Rt_map **dlmp, uint_t *binfo, Syminfo *sip, 27679aa23310Srie Rt_map *lmp, int *in_nfavl) 27687c478bd9Sstevel@tonic-gate { 27697c478bd9Sstevel@tonic-gate Rt_map *clmp = slp->sl_cmap; 27707c478bd9Sstevel@tonic-gate Sym *sym; 27717c478bd9Sstevel@tonic-gate Slookup sl; 27727c478bd9Sstevel@tonic-gate 27737c478bd9Sstevel@tonic-gate /* 27747c478bd9Sstevel@tonic-gate * If a direct binding resolves to the definition of a copy relocated 27757c478bd9Sstevel@tonic-gate * variable, it must be redirected to the copy (in the executable) that 27767c478bd9Sstevel@tonic-gate * will eventually be made. Typically, this redirection occurs in 27777c478bd9Sstevel@tonic-gate * lookup_sym_interpose(). But, there's an edge condition. If a 27787c478bd9Sstevel@tonic-gate * directly bound executable contains pic code, there may be a 27797c478bd9Sstevel@tonic-gate * reference to a definition that will eventually have a copy made. 27807c478bd9Sstevel@tonic-gate * However, this copy relocation may not yet have occurred, because 27817c478bd9Sstevel@tonic-gate * the relocation making this reference comes before the relocation 27827c478bd9Sstevel@tonic-gate * that will create the copy. 27837c478bd9Sstevel@tonic-gate * Under direct bindings, the syminfo indicates that a copy will be 27847c478bd9Sstevel@tonic-gate * taken (SYMINFO_FLG_COPY). This can only be set in an executable. 27857c478bd9Sstevel@tonic-gate * Thus, the caller must be the executable, so bind to the destination 27867c478bd9Sstevel@tonic-gate * of the copy within the executable. 27877c478bd9Sstevel@tonic-gate */ 27887c478bd9Sstevel@tonic-gate if (((slp->sl_flags & LKUP_COPY) == 0) && 27897c478bd9Sstevel@tonic-gate (sip->si_flags & SYMINFO_FLG_COPY)) { 27907c478bd9Sstevel@tonic-gate 27917c478bd9Sstevel@tonic-gate slp->sl_imap = LIST(clmp)->lm_head; 27929aa23310Srie if (sym = SYMINTP(clmp)(slp, dlmp, binfo, in_nfavl)) 27937c478bd9Sstevel@tonic-gate *binfo |= (DBG_BINFO_DIRECT | DBG_BINFO_COPYREF); 27947c478bd9Sstevel@tonic-gate return (sym); 27957c478bd9Sstevel@tonic-gate } 27967c478bd9Sstevel@tonic-gate 27977c478bd9Sstevel@tonic-gate /* 2798efb9e8b8Srie * If we need to directly bind to our parent, start looking in each 2799efb9e8b8Srie * callers link map. 28007c478bd9Sstevel@tonic-gate */ 28017c478bd9Sstevel@tonic-gate sl = *slp; 28027c478bd9Sstevel@tonic-gate sl.sl_flags |= LKUP_DIRECT; 2803adbfe822Srie sym = NULL; 28047c478bd9Sstevel@tonic-gate 28057c478bd9Sstevel@tonic-gate if (sip->si_boundto == SYMINFO_BT_PARENT) { 2806cce0e03bSab196087 Aliste idx1; 2807cce0e03bSab196087 Bnd_desc *bdp; 2808cce0e03bSab196087 Grp_hdl *ghp; 28097c478bd9Sstevel@tonic-gate 2810efb9e8b8Srie /* 2811efb9e8b8Srie * Determine the parent of this explicit dependency from its 2812efb9e8b8Srie * CALLERS()'s list. 2813efb9e8b8Srie */ 2814cce0e03bSab196087 for (APLIST_TRAVERSE(CALLERS(clmp), idx1, bdp)) { 2815cce0e03bSab196087 sl.sl_imap = lmp = bdp->b_caller; 28169aa23310Srie if ((sym = SYMINTP(lmp)(&sl, dlmp, binfo, 28179aa23310Srie in_nfavl)) != NULL) 2818efb9e8b8Srie goto found; 2819efb9e8b8Srie } 2820efb9e8b8Srie 2821efb9e8b8Srie /* 2822efb9e8b8Srie * A caller can also be defined as the parent of a dlopen() 2823efb9e8b8Srie * call. Determine whether this object has any handles. The 2824efb9e8b8Srie * dependencies maintained with the handle represent the 2825efb9e8b8Srie * explicit dependencies of the dlopen()'ed object, and the 2826efb9e8b8Srie * calling parent. 2827efb9e8b8Srie */ 2828cce0e03bSab196087 for (APLIST_TRAVERSE(HANDLES(clmp), idx1, ghp)) { 2829efb9e8b8Srie Grp_desc *gdp; 2830cce0e03bSab196087 Aliste idx2; 2831efb9e8b8Srie 2832cce0e03bSab196087 for (ALIST_TRAVERSE(ghp->gh_depends, idx2, gdp)) { 2833efb9e8b8Srie if ((gdp->gd_flags & GPD_PARENT) == 0) 2834efb9e8b8Srie continue; 2835efb9e8b8Srie sl.sl_imap = lmp = gdp->gd_depend; 2836aa736cbeSrie if ((sym = SYMINTP(lmp)(&sl, dlmp, 28379aa23310Srie binfo, in_nfavl)) != NULL) 2838efb9e8b8Srie goto found; 2839efb9e8b8Srie } 28407c478bd9Sstevel@tonic-gate } 28417c478bd9Sstevel@tonic-gate } else { 28427c478bd9Sstevel@tonic-gate /* 28437c478bd9Sstevel@tonic-gate * If we need to direct bind to anything else look in the 28447c478bd9Sstevel@tonic-gate * link map associated with this symbol reference. 28457c478bd9Sstevel@tonic-gate */ 28467c478bd9Sstevel@tonic-gate if (sip->si_boundto == SYMINFO_BT_SELF) 28477c478bd9Sstevel@tonic-gate sl.sl_imap = lmp = clmp; 28487c478bd9Sstevel@tonic-gate else 28497c478bd9Sstevel@tonic-gate sl.sl_imap = lmp; 28507c478bd9Sstevel@tonic-gate 28517c478bd9Sstevel@tonic-gate if (lmp) 28529aa23310Srie sym = SYMINTP(lmp)(&sl, dlmp, binfo, in_nfavl); 28537c478bd9Sstevel@tonic-gate } 2854efb9e8b8Srie found: 28557c478bd9Sstevel@tonic-gate if (sym) 28567c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_DIRECT; 28577c478bd9Sstevel@tonic-gate 28587c478bd9Sstevel@tonic-gate /* 2859adbfe822Srie * If a reference to a directly bound symbol can't be satisfied, then 2860adbfe822Srie * determine whether an interposer can provide the missing symbol. If 2861adbfe822Srie * a reference to a directly bound symbol is satisfied, then determine 2862adbfe822Srie * whether that object can be interposed upon for this symbol. 28637c478bd9Sstevel@tonic-gate */ 2864adbfe822Srie if ((sym == NULL) || ((LIST(*dlmp)->lm_head != *dlmp) && 2865adbfe822Srie (LIST(*dlmp) == LIST(clmp)))) { 28667c478bd9Sstevel@tonic-gate Sym *isym; 28677c478bd9Sstevel@tonic-gate 2868adbfe822Srie if ((isym = lookup_sym_interpose(slp, dlmp, binfo, sym, 2869adbfe822Srie in_nfavl)) != 0) 28707c478bd9Sstevel@tonic-gate return (isym); 28717c478bd9Sstevel@tonic-gate } 28727c478bd9Sstevel@tonic-gate 28737c478bd9Sstevel@tonic-gate return (sym); 28747c478bd9Sstevel@tonic-gate } 28757c478bd9Sstevel@tonic-gate 28767c478bd9Sstevel@tonic-gate static Sym * 287760758829Srie core_lookup_sym(Rt_map *ilmp, Slookup *slp, Rt_map **dlmp, uint_t *binfo, 28789aa23310Srie Aliste off, int *in_nfavl) 28797c478bd9Sstevel@tonic-gate { 28807c478bd9Sstevel@tonic-gate Rt_map *lmp; 28817c478bd9Sstevel@tonic-gate 28827c478bd9Sstevel@tonic-gate /* 28837c478bd9Sstevel@tonic-gate * Copy relocations should start their search after the head of the 28847c478bd9Sstevel@tonic-gate * main link-map control list. 28857c478bd9Sstevel@tonic-gate */ 2886cce0e03bSab196087 if ((off == ALIST_OFF_DATA) && (slp->sl_flags & LKUP_COPY) && ilmp) 2887cb511613SAli Bahrami lmp = NEXT_RT_MAP(ilmp); 28887c478bd9Sstevel@tonic-gate else 28897c478bd9Sstevel@tonic-gate lmp = ilmp; 28907c478bd9Sstevel@tonic-gate 2891cb511613SAli Bahrami for (; lmp; lmp = NEXT_RT_MAP(lmp)) { 289260758829Srie if (callable(slp->sl_cmap, lmp, 0, slp->sl_flags)) { 28937c478bd9Sstevel@tonic-gate Sym *sym; 28947c478bd9Sstevel@tonic-gate 28957c478bd9Sstevel@tonic-gate slp->sl_imap = lmp; 28969aa23310Srie if (((sym = SYMINTP(lmp)(slp, dlmp, binfo, 289737ffaf83SRod Evans in_nfavl)) != NULL) || 289837ffaf83SRod Evans (*binfo & BINFO_MSK_TRYAGAIN)) 28997c478bd9Sstevel@tonic-gate return (sym); 29007c478bd9Sstevel@tonic-gate } 29017c478bd9Sstevel@tonic-gate } 290237ffaf83SRod Evans return (NULL); 29037c478bd9Sstevel@tonic-gate } 29047c478bd9Sstevel@tonic-gate 29057c478bd9Sstevel@tonic-gate static Sym * 29062017c965SRod Evans rescan_lazy_find_sym(Rt_map *ilmp, Slookup *slp, Rt_map **dlmp, uint_t *binfo, 29079aa23310Srie int *in_nfavl) 29087c478bd9Sstevel@tonic-gate { 29097c478bd9Sstevel@tonic-gate Rt_map *lmp; 29107c478bd9Sstevel@tonic-gate 2911cb511613SAli Bahrami for (lmp = ilmp; lmp; lmp = NEXT_RT_MAP(lmp)) { 29127c478bd9Sstevel@tonic-gate if (LAZY(lmp) == 0) 29137c478bd9Sstevel@tonic-gate continue; 291460758829Srie if (callable(slp->sl_cmap, lmp, 0, slp->sl_flags)) { 29157c478bd9Sstevel@tonic-gate Sym *sym; 29167c478bd9Sstevel@tonic-gate 29177c478bd9Sstevel@tonic-gate slp->sl_imap = lmp; 29189aa23310Srie if ((sym = elf_lazy_find_sym(slp, dlmp, binfo, 29199aa23310Srie in_nfavl)) != 0) 29207c478bd9Sstevel@tonic-gate return (sym); 29217c478bd9Sstevel@tonic-gate } 29227c478bd9Sstevel@tonic-gate } 292337ffaf83SRod Evans return (NULL); 29247c478bd9Sstevel@tonic-gate } 29257c478bd9Sstevel@tonic-gate 292660758829Srie static Sym * 29279aa23310Srie _lookup_sym(Slookup *slp, Rt_map **dlmp, uint_t *binfo, int *in_nfavl) 29287c478bd9Sstevel@tonic-gate { 29297c478bd9Sstevel@tonic-gate const char *name = slp->sl_name; 29307c478bd9Sstevel@tonic-gate Rt_map *clmp = slp->sl_cmap; 2931dae2dfb7Srie Lm_list *lml = LIST(clmp); 29327c478bd9Sstevel@tonic-gate Rt_map *ilmp = slp->sl_imap, *lmp; 29337c478bd9Sstevel@tonic-gate ulong_t rsymndx; 293460758829Srie Sym *sym; 29357c478bd9Sstevel@tonic-gate Syminfo *sip; 29367c478bd9Sstevel@tonic-gate Slookup sl; 29377c478bd9Sstevel@tonic-gate 29387c478bd9Sstevel@tonic-gate /* 29397c478bd9Sstevel@tonic-gate * Search the initial link map for the required symbol (this category is 29407c478bd9Sstevel@tonic-gate * selected by dlsym(), where individual link maps are searched for a 29417c478bd9Sstevel@tonic-gate * required symbol. Therefore, we know we have permission to look at 29427c478bd9Sstevel@tonic-gate * the link map). 29437c478bd9Sstevel@tonic-gate */ 294460758829Srie if (slp->sl_flags & LKUP_FIRST) 29459aa23310Srie return (SYMINTP(ilmp)(slp, dlmp, binfo, in_nfavl)); 29467c478bd9Sstevel@tonic-gate 29477c478bd9Sstevel@tonic-gate /* 29487c478bd9Sstevel@tonic-gate * Determine whether this lookup can be satisfied by an objects direct, 29497c478bd9Sstevel@tonic-gate * or lazy binding information. This is triggered by a relocation from 29507c478bd9Sstevel@tonic-gate * the object (hence rsymndx is set). 29517c478bd9Sstevel@tonic-gate */ 29527c478bd9Sstevel@tonic-gate if (((rsymndx = slp->sl_rsymndx) != 0) && 2953aa736cbeSrie ((sip = SYMINFO(clmp)) != NULL)) { 2954dae2dfb7Srie uint_t bound; 2955dae2dfb7Srie 29567c478bd9Sstevel@tonic-gate /* 29577c478bd9Sstevel@tonic-gate * Find the corresponding Syminfo entry for the original 29587c478bd9Sstevel@tonic-gate * referencing symbol. 29597c478bd9Sstevel@tonic-gate */ 29607c478bd9Sstevel@tonic-gate /* LINTED */ 29617c478bd9Sstevel@tonic-gate sip = (Syminfo *)((char *)sip + (rsymndx * SYMINENT(clmp))); 2962dae2dfb7Srie bound = sip->si_boundto; 2963dae2dfb7Srie 2964dae2dfb7Srie /* 2965dae2dfb7Srie * Identify any EXTERN or PARENT references for ldd(1). 2966dae2dfb7Srie */ 2967dae2dfb7Srie if ((lml->lm_flags & LML_FLG_TRC_WARN) && 2968dae2dfb7Srie (bound > SYMINFO_BT_LOWRESERVE)) { 2969dae2dfb7Srie if (bound == SYMINFO_BT_PARENT) 2970dae2dfb7Srie *binfo |= DBG_BINFO_REF_PARENT; 2971dae2dfb7Srie if (bound == SYMINFO_BT_EXTERN) 2972dae2dfb7Srie *binfo |= DBG_BINFO_REF_EXTERN; 2973dae2dfb7Srie } 29747c478bd9Sstevel@tonic-gate 29757c478bd9Sstevel@tonic-gate /* 29767c478bd9Sstevel@tonic-gate * If the symbol information indicates a direct binding, 29777c478bd9Sstevel@tonic-gate * determine the link map that is required to satisfy the 29787c478bd9Sstevel@tonic-gate * binding. Note, if the dependency can not be found, but a 29797c478bd9Sstevel@tonic-gate * direct binding isn't required, we will still fall through 29807c478bd9Sstevel@tonic-gate * to perform any default symbol search. 29817c478bd9Sstevel@tonic-gate */ 29827c478bd9Sstevel@tonic-gate if (sip->si_flags & SYMINFO_FLG_DIRECT) { 29837c478bd9Sstevel@tonic-gate 29847c478bd9Sstevel@tonic-gate lmp = 0; 29857c478bd9Sstevel@tonic-gate if (bound < SYMINFO_BT_LOWRESERVE) 29869aa23310Srie lmp = elf_lazy_load(clmp, slp, bound, 29872017c965SRod Evans name, 0, NULL, in_nfavl); 29887c478bd9Sstevel@tonic-gate 29897c478bd9Sstevel@tonic-gate /* 29907c478bd9Sstevel@tonic-gate * If direct bindings have been disabled, and this isn't 29917c478bd9Sstevel@tonic-gate * a translator, skip any direct binding now that we've 299260758829Srie * ensured the resolving object has been loaded. 29937c478bd9Sstevel@tonic-gate * 29947c478bd9Sstevel@tonic-gate * If we need to direct bind to anything, we look in 29957c478bd9Sstevel@tonic-gate * ourselves, our parent, or in the link map we've just 29967c478bd9Sstevel@tonic-gate * loaded. Otherwise, even though we may have lazily 29977c478bd9Sstevel@tonic-gate * loaded an object we still continue to search for 29987c478bd9Sstevel@tonic-gate * symbols from the head of the link map list. 29997c478bd9Sstevel@tonic-gate */ 30007c478bd9Sstevel@tonic-gate if (((FLAGS(clmp) & FLG_RT_TRANS) || 3001dae2dfb7Srie (((lml->lm_tflags & LML_TFLG_NODIRECT) == 0) && 3002dae2dfb7Srie ((slp->sl_flags & LKUP_SINGLETON) == 0))) && 30039a411307Srie ((FLAGS1(clmp) & FL1_RT_DIRECT) || 30047c478bd9Sstevel@tonic-gate (sip->si_flags & SYMINFO_FLG_DIRECTBIND))) { 30057c478bd9Sstevel@tonic-gate sym = lookup_sym_direct(slp, dlmp, binfo, 30069aa23310Srie sip, lmp, in_nfavl); 30077c478bd9Sstevel@tonic-gate 30087c478bd9Sstevel@tonic-gate /* 300960758829Srie * Determine whether this direct binding has 301060758829Srie * been rejected. If we've bound to a singleton 301160758829Srie * without following a singleton search, then 301260758829Srie * return. The caller detects this condition 301360758829Srie * and will trigger a new singleton search. 301460758829Srie * 301560758829Srie * For any other rejection (such as binding to 301660758829Srie * a symbol labeled as nodirect - presumably 301760758829Srie * because the symbol definition has been 301860758829Srie * changed since the referring object was last 301960758829Srie * built), fall through to a standard symbol 30207c478bd9Sstevel@tonic-gate * search. 30217c478bd9Sstevel@tonic-gate */ 302237ffaf83SRod Evans if (((*binfo & BINFO_MSK_REJECTED) == 0) || 302337ffaf83SRod Evans (*binfo & BINFO_MSK_TRYAGAIN)) 30247c478bd9Sstevel@tonic-gate return (sym); 302560758829Srie 302637ffaf83SRod Evans *binfo &= ~BINFO_MSK_REJECTED; 30277c478bd9Sstevel@tonic-gate } 30287c478bd9Sstevel@tonic-gate } 30297c478bd9Sstevel@tonic-gate } 30307c478bd9Sstevel@tonic-gate 303160758829Srie /* 303260758829Srie * Duplicate the lookup information, as we'll need to modify this 303360758829Srie * information for some of the following searches. 303460758829Srie */ 30357c478bd9Sstevel@tonic-gate sl = *slp; 30367c478bd9Sstevel@tonic-gate 30377c478bd9Sstevel@tonic-gate /* 30387c478bd9Sstevel@tonic-gate * If the referencing object has the DF_SYMBOLIC flag set, look in the 30397c478bd9Sstevel@tonic-gate * referencing object for the symbol first. Failing that, fall back to 30407c478bd9Sstevel@tonic-gate * our generic search. 30417c478bd9Sstevel@tonic-gate */ 304260758829Srie if ((FLAGS1(clmp) & FL1_RT_SYMBOLIC) && 304360758829Srie ((sl.sl_flags & LKUP_SINGLETON) == 0)) { 30447c478bd9Sstevel@tonic-gate sl.sl_imap = clmp; 30459aa23310Srie if (sym = SYMINTP(clmp)(&sl, dlmp, binfo, in_nfavl)) { 30469a411307Srie ulong_t dsymndx = (((ulong_t)sym - 30479a411307Srie (ulong_t)SYMTAB(*dlmp)) / SYMENT(*dlmp)); 30489a411307Srie 30499a411307Srie /* 30509a411307Srie * Make sure this symbol hasn't explicitly been defined 30519a411307Srie * as nodirect. 30529a411307Srie */ 30539a411307Srie if (((sip = SYMINFO(*dlmp)) == 0) || 30549a411307Srie /* LINTED */ 30559a411307Srie ((sip = (Syminfo *)((char *)sip + 30569a411307Srie (dsymndx * SYMINENT(*dlmp)))) == 0) || 30579a411307Srie ((sip->si_flags & SYMINFO_FLG_NOEXTDIRECT) == 0)) 30587c478bd9Sstevel@tonic-gate return (sym); 30597c478bd9Sstevel@tonic-gate } 30609a411307Srie } 30617c478bd9Sstevel@tonic-gate 306260758829Srie sl.sl_flags |= LKUP_STANDARD; 306360758829Srie 30647c478bd9Sstevel@tonic-gate /* 30657c478bd9Sstevel@tonic-gate * If this lookup originates from a standard relocation, then traverse 306660758829Srie * all link-map control lists, inspecting any object that is available 306760758829Srie * to this caller. Otherwise, traverse the link-map control list 306860758829Srie * associated with the caller. 30697c478bd9Sstevel@tonic-gate */ 307060758829Srie if (sl.sl_flags & LKUP_STDRELOC) { 30717c478bd9Sstevel@tonic-gate Aliste off; 30727c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 30737c478bd9Sstevel@tonic-gate 307460758829Srie sym = NULL; 30757c478bd9Sstevel@tonic-gate 3076dae2dfb7Srie for (ALIST_TRAVERSE_BY_OFFSET(lml->lm_lists, off, lmc)) { 307760758829Srie if (((sym = core_lookup_sym(lmc->lc_head, &sl, dlmp, 30789aa23310Srie binfo, off, in_nfavl)) != NULL) || 307937ffaf83SRod Evans (*binfo & BINFO_MSK_TRYAGAIN)) 30807c478bd9Sstevel@tonic-gate break; 30817c478bd9Sstevel@tonic-gate } 30827c478bd9Sstevel@tonic-gate } else 30839aa23310Srie sym = core_lookup_sym(ilmp, &sl, dlmp, binfo, ALIST_OFF_DATA, 30849aa23310Srie in_nfavl); 308560758829Srie 308660758829Srie /* 308737ffaf83SRod Evans * If a symbol binding should be retried, return so that the search can 308837ffaf83SRod Evans * be repeated. 308960758829Srie */ 309037ffaf83SRod Evans if (*binfo & BINFO_MSK_TRYAGAIN) 309160758829Srie return (sym); 30927c478bd9Sstevel@tonic-gate 30937c478bd9Sstevel@tonic-gate /* 30947c478bd9Sstevel@tonic-gate * To allow transitioning into a world of lazy loading dependencies see 30957c478bd9Sstevel@tonic-gate * if this link map contains objects that have lazy dependencies still 30967c478bd9Sstevel@tonic-gate * outstanding. If so, and we haven't been able to locate a non-weak 30977c478bd9Sstevel@tonic-gate * symbol reference, start bringing in any lazy dependencies to see if 30987c478bd9Sstevel@tonic-gate * the reference can be satisfied. Use of dlsym(RTLD_PROBE) sets the 309975e7992aSrie * LKUP_NOFALLBACK flag, and this flag disables this fall back. 31007c478bd9Sstevel@tonic-gate */ 310175e7992aSrie if ((sym == NULL) && ((sl.sl_flags & LKUP_NOFALLBACK) == 0)) { 31027c478bd9Sstevel@tonic-gate if ((lmp = ilmp) == 0) 31037c478bd9Sstevel@tonic-gate lmp = LIST(clmp)->lm_head; 310475e7992aSrie 3105dae2dfb7Srie lml = LIST(lmp); 3106dae2dfb7Srie if ((sl.sl_flags & LKUP_WEAK) || (lml->lm_lazy == 0)) 310737ffaf83SRod Evans return (NULL); 31087c478bd9Sstevel@tonic-gate 3109dae2dfb7Srie DBG_CALL(Dbg_syms_lazy_rescan(lml, name)); 31107c478bd9Sstevel@tonic-gate 31117c478bd9Sstevel@tonic-gate /* 31127c478bd9Sstevel@tonic-gate * If this request originated from a dlsym(RTLD_NEXT) then start 31137c478bd9Sstevel@tonic-gate * looking for dependencies from the caller, otherwise use the 31147c478bd9Sstevel@tonic-gate * initial link-map. 31157c478bd9Sstevel@tonic-gate */ 311660758829Srie if (sl.sl_flags & LKUP_NEXT) 31172017c965SRod Evans sym = rescan_lazy_find_sym(clmp, &sl, dlmp, binfo, 31182017c965SRod Evans in_nfavl); 31197c478bd9Sstevel@tonic-gate else { 3120cce0e03bSab196087 Aliste idx; 31217c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 31227c478bd9Sstevel@tonic-gate 3123dae2dfb7Srie for (ALIST_TRAVERSE(lml->lm_lists, idx, lmc)) { 312475e7992aSrie sl.sl_flags |= LKUP_NOFALLBACK; 31252017c965SRod Evans if ((sym = rescan_lazy_find_sym(lmc->lc_head, 31262017c965SRod Evans &sl, dlmp, binfo, in_nfavl)) != NULL) 31277c478bd9Sstevel@tonic-gate break; 31287c478bd9Sstevel@tonic-gate } 31297c478bd9Sstevel@tonic-gate } 31307c478bd9Sstevel@tonic-gate } 313160758829Srie return (sym); 313260758829Srie } 313360758829Srie 313460758829Srie /* 313560758829Srie * Symbol lookup routine. Takes an ELF symbol name, and a list of link maps to 313660758829Srie * search. If successful, return a pointer to the symbol table entry, a 313760758829Srie * pointer to the link map of the enclosing object, and information relating 313860758829Srie * to the type of binding. Else return a null pointer. 313960758829Srie * 314060758829Srie * To improve elf performance, we first compute the elf hash value and pass 314160758829Srie * it to each find_sym() routine. The elf function will use this value to 314260758829Srie * locate the symbol, the a.out function will simply ignore it. 314360758829Srie */ 314460758829Srie Sym * 31459aa23310Srie lookup_sym(Slookup *slp, Rt_map **dlmp, uint_t *binfo, int *in_nfavl) 314660758829Srie { 314760758829Srie Rt_map *clmp = slp->sl_cmap; 31482017c965SRod Evans Sym *rsym = slp->sl_rsym, *sym = NULL; 314960758829Srie uchar_t rtype = slp->sl_rtype; 315037ffaf83SRod Evans int mode; 315160758829Srie 315260758829Srie if (slp->sl_hash == 0) 315375e7992aSrie slp->sl_hash = elf_hash(slp->sl_name); 315460758829Srie *binfo = 0; 315560758829Srie 315660758829Srie /* 315760758829Srie * Establish any state that might be associated with a symbol reference. 315860758829Srie */ 315960758829Srie if (rsym) { 316060758829Srie if ((slp->sl_flags & LKUP_STDRELOC) && 316160758829Srie (ELF_ST_BIND(rsym->st_info) == STB_WEAK)) 316260758829Srie slp->sl_flags |= LKUP_WEAK; 316360758829Srie 316460758829Srie if (ELF_ST_VISIBILITY(rsym->st_other) == STV_SINGLETON) 316560758829Srie slp->sl_flags |= LKUP_SINGLETON; 316660758829Srie } 316760758829Srie 316860758829Srie /* 316960758829Srie * Establish any lookup state required for this type of relocation. 317060758829Srie */ 317160758829Srie if ((slp->sl_flags & LKUP_STDRELOC) && rtype) { 317260758829Srie if (rtype == M_R_COPY) 317360758829Srie slp->sl_flags |= LKUP_COPY; 317460758829Srie 317560758829Srie if (rtype != M_R_JMP_SLOT) 317660758829Srie slp->sl_flags |= LKUP_SPEC; 317760758829Srie } 317860758829Srie 317960758829Srie /* 318060758829Srie * Under ldd -w, any unresolved weak references are diagnosed. Set the 318160758829Srie * symbol binding as global to trigger a relocation error if the symbol 318260758829Srie * can not be found. 318360758829Srie */ 318460758829Srie if (rsym) { 318560758829Srie if (LIST(slp->sl_cmap)->lm_flags & LML_FLG_TRC_NOUNRESWEAK) 318660758829Srie slp->sl_bind = STB_GLOBAL; 318760758829Srie else if ((slp->sl_bind = ELF_ST_BIND(rsym->st_info)) == 318860758829Srie STB_WEAK) 318960758829Srie slp->sl_flags |= LKUP_WEAK; 319060758829Srie } 319160758829Srie 319260758829Srie /* 319337ffaf83SRod Evans * Save the callers MODE(). 319437ffaf83SRod Evans */ 319537ffaf83SRod Evans mode = MODE(clmp); 319637ffaf83SRod Evans 319737ffaf83SRod Evans /* 319860758829Srie * Carry out an initial symbol search. This search takes into account 319960758829Srie * all the modes of the requested search. 320060758829Srie */ 32019aa23310Srie if (((sym = _lookup_sym(slp, dlmp, binfo, in_nfavl)) == NULL) && 320237ffaf83SRod Evans (*binfo & BINFO_MSK_TRYAGAIN)) { 320360758829Srie Slookup sl = *slp; 320460758829Srie 320560758829Srie /* 320637ffaf83SRod Evans * Try the symbol search again. This retry can be necessary if: 320737ffaf83SRod Evans * 32082017c965SRod Evans * - a binding has been rejected because of binding to a 320937ffaf83SRod Evans * singleton without going through a singleton search. 32102017c965SRod Evans * - a group binding has resulted in binding to a symbol 321137ffaf83SRod Evans * that indicates no-direct binding. 321237ffaf83SRod Evans * 321337ffaf83SRod Evans * Reset the lookup data, and try again. 321460758829Srie */ 321560758829Srie sl.sl_imap = LIST(sl.sl_cmap)->lm_head; 321660758829Srie sl.sl_flags &= ~(LKUP_FIRST | LKUP_SELF | LKUP_NEXT); 321760758829Srie sl.sl_rsymndx = 0; 321837ffaf83SRod Evans 321937ffaf83SRod Evans if (*binfo & BINFO_REJSINGLE) 322037ffaf83SRod Evans sl.sl_flags |= LKUP_SINGLETON; 322137ffaf83SRod Evans if (*binfo & BINFO_REJGROUP) { 322237ffaf83SRod Evans sl.sl_flags |= LKUP_WORLD; 322337ffaf83SRod Evans mode |= RTLD_WORLD; 322437ffaf83SRod Evans } 322537ffaf83SRod Evans *binfo &= ~BINFO_MSK_REJECTED; 322637ffaf83SRod Evans 32279aa23310Srie sym = _lookup_sym(&sl, dlmp, binfo, in_nfavl); 322860758829Srie } 32297c478bd9Sstevel@tonic-gate 32307c478bd9Sstevel@tonic-gate /* 32317c478bd9Sstevel@tonic-gate * If the caller is restricted to a symbol search within its group, 32327c478bd9Sstevel@tonic-gate * determine if it is necessary to follow a binding from outside of 32337c478bd9Sstevel@tonic-gate * the group. 32347c478bd9Sstevel@tonic-gate */ 323537ffaf83SRod Evans if ((mode & (RTLD_GROUP | RTLD_WORLD)) == RTLD_GROUP) { 32367c478bd9Sstevel@tonic-gate Sym *isym; 32377c478bd9Sstevel@tonic-gate 3238adbfe822Srie if ((isym = lookup_sym_interpose(slp, dlmp, binfo, sym, 323937ffaf83SRod Evans in_nfavl)) != NULL) 32407c478bd9Sstevel@tonic-gate return (isym); 32417c478bd9Sstevel@tonic-gate } 32427c478bd9Sstevel@tonic-gate return (sym); 32437c478bd9Sstevel@tonic-gate } 32447c478bd9Sstevel@tonic-gate 32457c478bd9Sstevel@tonic-gate /* 32467c478bd9Sstevel@tonic-gate * Associate a binding descriptor with a caller and its dependency, or update 32477c478bd9Sstevel@tonic-gate * an existing descriptor. 32487c478bd9Sstevel@tonic-gate */ 32497c478bd9Sstevel@tonic-gate int 32507c478bd9Sstevel@tonic-gate bind_one(Rt_map *clmp, Rt_map *dlmp, uint_t flags) 32517c478bd9Sstevel@tonic-gate { 3252cce0e03bSab196087 Bnd_desc *bdp; 3253cce0e03bSab196087 Aliste idx; 32547c478bd9Sstevel@tonic-gate int found = ALE_CREATE; 32557c478bd9Sstevel@tonic-gate 32567c478bd9Sstevel@tonic-gate /* 32577c478bd9Sstevel@tonic-gate * Determine whether a binding descriptor already exists between the 32587c478bd9Sstevel@tonic-gate * two objects. 32597c478bd9Sstevel@tonic-gate */ 3260cce0e03bSab196087 for (APLIST_TRAVERSE(DEPENDS(clmp), idx, bdp)) { 32617c478bd9Sstevel@tonic-gate if (bdp->b_depend == dlmp) { 32627c478bd9Sstevel@tonic-gate found = ALE_EXISTS; 32637c478bd9Sstevel@tonic-gate break; 32647c478bd9Sstevel@tonic-gate } 32657c478bd9Sstevel@tonic-gate } 32667c478bd9Sstevel@tonic-gate 32677c478bd9Sstevel@tonic-gate if (found == ALE_CREATE) { 32687c478bd9Sstevel@tonic-gate /* 32697c478bd9Sstevel@tonic-gate * Create a new binding descriptor. 32707c478bd9Sstevel@tonic-gate */ 327137ffaf83SRod Evans if ((bdp = malloc(sizeof (Bnd_desc))) == NULL) 32727c478bd9Sstevel@tonic-gate return (0); 32737c478bd9Sstevel@tonic-gate 32747c478bd9Sstevel@tonic-gate bdp->b_caller = clmp; 32757c478bd9Sstevel@tonic-gate bdp->b_depend = dlmp; 32767c478bd9Sstevel@tonic-gate bdp->b_flags = 0; 32777c478bd9Sstevel@tonic-gate 32787c478bd9Sstevel@tonic-gate /* 32797c478bd9Sstevel@tonic-gate * Append the binding descriptor to the caller and the 32807c478bd9Sstevel@tonic-gate * dependency. 32817c478bd9Sstevel@tonic-gate */ 328256deab07SRod Evans if (aplist_append(&DEPENDS(clmp), bdp, AL_CNT_DEPENDS) == NULL) 32837c478bd9Sstevel@tonic-gate return (0); 32847c478bd9Sstevel@tonic-gate 328556deab07SRod Evans if (aplist_append(&CALLERS(dlmp), bdp, AL_CNT_CALLERS) == NULL) 32867c478bd9Sstevel@tonic-gate return (0); 32877c478bd9Sstevel@tonic-gate } 32887c478bd9Sstevel@tonic-gate 32897c478bd9Sstevel@tonic-gate if ((found == ALE_CREATE) || ((bdp->b_flags & flags) != flags)) { 32907c478bd9Sstevel@tonic-gate bdp->b_flags |= flags; 32917c478bd9Sstevel@tonic-gate 32927c478bd9Sstevel@tonic-gate if (flags & BND_REFER) 32937c478bd9Sstevel@tonic-gate FLAGS1(dlmp) |= FL1_RT_USED; 32947c478bd9Sstevel@tonic-gate 32955aefb655Srie DBG_CALL(Dbg_file_bind_entry(LIST(clmp), bdp)); 32967c478bd9Sstevel@tonic-gate } 32977c478bd9Sstevel@tonic-gate return (found); 32987c478bd9Sstevel@tonic-gate } 32997c478bd9Sstevel@tonic-gate 33007c478bd9Sstevel@tonic-gate /* 33017c478bd9Sstevel@tonic-gate * Cleanup after relocation processing. 33027c478bd9Sstevel@tonic-gate */ 33037c478bd9Sstevel@tonic-gate int 330456deab07SRod Evans relocate_finish(Rt_map *lmp, APlist *bound, int ret) 33057c478bd9Sstevel@tonic-gate { 33065aefb655Srie DBG_CALL(Dbg_reloc_run(lmp, 0, ret, DBG_REL_FINISH)); 33077c478bd9Sstevel@tonic-gate 33087c478bd9Sstevel@tonic-gate /* 33097c478bd9Sstevel@tonic-gate * Establish bindings to all objects that have been bound to. 33107c478bd9Sstevel@tonic-gate */ 33117c478bd9Sstevel@tonic-gate if (bound) { 3312cce0e03bSab196087 Rt_map *_lmp; 33138a20d9f8Srie Word used; 33147c478bd9Sstevel@tonic-gate 33158a20d9f8Srie /* 33168a20d9f8Srie * Only create bindings if the callers relocation was 33178a20d9f8Srie * successful (ret != 0), otherwise the object will eventually 33188a20d9f8Srie * be torn down. Create these bindings if running under ldd(1) 33198a20d9f8Srie * with the -U/-u options regardless of relocation errors, as 33208a20d9f8Srie * the unused processing needs to traverse these bindings to 33218a20d9f8Srie * diagnose unused objects. 33228a20d9f8Srie */ 33238a20d9f8Srie used = LIST(lmp)->lm_flags & 33248a20d9f8Srie (LML_FLG_TRC_UNREF | LML_FLG_TRC_UNUSED); 33258a20d9f8Srie 33268a20d9f8Srie if (ret || used) { 332756deab07SRod Evans Aliste idx; 332856deab07SRod Evans 3329cce0e03bSab196087 for (APLIST_TRAVERSE(bound, idx, _lmp)) { 33308a20d9f8Srie if (bind_one(lmp, _lmp, BND_REFER) || used) 33318a20d9f8Srie continue; 33328a20d9f8Srie 33337c478bd9Sstevel@tonic-gate ret = 0; 33347c478bd9Sstevel@tonic-gate break; 33357c478bd9Sstevel@tonic-gate } 33367c478bd9Sstevel@tonic-gate } 33377c478bd9Sstevel@tonic-gate free(bound); 33387c478bd9Sstevel@tonic-gate } 33397c478bd9Sstevel@tonic-gate 33407c478bd9Sstevel@tonic-gate return (ret); 33417c478bd9Sstevel@tonic-gate } 334256deab07SRod Evans 334356deab07SRod Evans /* 334456deab07SRod Evans * Function to correct protection settings. Segments are all mapped initially 334556deab07SRod Evans * with permissions as given in the segment header. We need to turn on write 334656deab07SRod Evans * permissions on a text segment if there are any relocations against that 334756deab07SRod Evans * segment, and then turn write permission back off again before returning 334856deab07SRod Evans * control to the caller. This function turns the permission on or off 334956deab07SRod Evans * depending on the value of the permission argument. 335056deab07SRod Evans */ 335156deab07SRod Evans int 335256deab07SRod Evans set_prot(Rt_map *lmp, mmapobj_result_t *mpp, int perm) 335356deab07SRod Evans { 335456deab07SRod Evans int prot; 335556deab07SRod Evans 335656deab07SRod Evans /* 335756deab07SRod Evans * If this is an allocated image (ie. a relocatable object) we can't 335856deab07SRod Evans * mprotect() anything. 335956deab07SRod Evans */ 336056deab07SRod Evans if (FLAGS(lmp) & FLG_RT_IMGALLOC) 336156deab07SRod Evans return (1); 336256deab07SRod Evans 336356deab07SRod Evans DBG_CALL(Dbg_file_prot(lmp, perm)); 336456deab07SRod Evans 336556deab07SRod Evans if (perm) 336656deab07SRod Evans prot = mpp->mr_prot | PROT_WRITE; 336756deab07SRod Evans else 336856deab07SRod Evans prot = mpp->mr_prot & ~PROT_WRITE; 336956deab07SRod Evans 337056deab07SRod Evans if (mprotect((void *)(uintptr_t)mpp->mr_addr, 337156deab07SRod Evans mpp->mr_msize, prot) == -1) { 337256deab07SRod Evans int err = errno; 337356deab07SRod Evans eprintf(LIST(lmp), ERR_FATAL, MSG_INTL(MSG_SYS_MPROT), 337456deab07SRod Evans NAME(lmp), strerror(err)); 337556deab07SRod Evans return (0); 337656deab07SRod Evans } 337756deab07SRod Evans mpp->mr_prot = prot; 337856deab07SRod Evans return (1); 337956deab07SRod Evans } 3380