17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 55aefb655Srie * Common Development and Distribution License (the "License"). 65aefb655Srie * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21fb1354edSrie 227c478bd9Sstevel@tonic-gate /* 23f441771bSRod Evans * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267257d1b4Sraf /* 277257d1b4Sraf * Copyright (c) 1988 AT&T 287257d1b4Sraf * All Rights Reserved 297257d1b4Sraf */ 307257d1b4Sraf 317c478bd9Sstevel@tonic-gate #include <string.h> 327c478bd9Sstevel@tonic-gate #include <stdio.h> 337c478bd9Sstevel@tonic-gate #include <unistd.h> 347c478bd9Sstevel@tonic-gate #include <sys/stat.h> 357c478bd9Sstevel@tonic-gate #include <sys/mman.h> 3656deab07SRod Evans #include <sys/debug.h> 377c478bd9Sstevel@tonic-gate #include <fcntl.h> 387c478bd9Sstevel@tonic-gate #include <limits.h> 397c478bd9Sstevel@tonic-gate #include <dlfcn.h> 407c478bd9Sstevel@tonic-gate #include <errno.h> 417c478bd9Sstevel@tonic-gate #include <link.h> 425aefb655Srie #include <debug.h> 435aefb655Srie #include <conv.h> 447c478bd9Sstevel@tonic-gate #include "_rtld.h" 457c478bd9Sstevel@tonic-gate #include "_audit.h" 467c478bd9Sstevel@tonic-gate #include "_elf.h" 47f441771bSRod Evans #include "_inline_gen.h" 487c478bd9Sstevel@tonic-gate #include "msg.h" 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate /* 517c478bd9Sstevel@tonic-gate * If a load filter flag is in effect, and this object is a filter, trigger the 527c478bd9Sstevel@tonic-gate * loading of all its filtees. The load filter flag is in effect when creating 537c478bd9Sstevel@tonic-gate * configuration files, or when under the control of ldd(1), or the LD_LOADFLTR 547c478bd9Sstevel@tonic-gate * environment variable is set, or this object was built with the -zloadfltr 557c478bd9Sstevel@tonic-gate * flag. Otherwise, filtee loading is deferred until triggered by a relocation. 567c478bd9Sstevel@tonic-gate */ 577c478bd9Sstevel@tonic-gate static void 589aa23310Srie load_filtees(Rt_map *lmp, int *in_nfavl) 597c478bd9Sstevel@tonic-gate { 607c478bd9Sstevel@tonic-gate if ((FLAGS1(lmp) & MSK_RT_FILTER) && 617c478bd9Sstevel@tonic-gate ((FLAGS(lmp) & FLG_RT_LOADFLTR) || 627c478bd9Sstevel@tonic-gate (LIST(lmp)->lm_tflags & LML_TFLG_LOADFLTR))) { 637c478bd9Sstevel@tonic-gate Dyninfo *dip = DYNINFO(lmp); 647c478bd9Sstevel@tonic-gate uint_t cnt, max = DYNINFOCNT(lmp); 657c478bd9Sstevel@tonic-gate Slookup sl; 667c478bd9Sstevel@tonic-gate 6775e7992aSrie /* 6808278a5eSRod Evans * Initialize the symbol lookup data structure. Note, no symbol 6908278a5eSRod Evans * name is supplied. This NULL name causes filters to be loaded 7008278a5eSRod Evans * but no symbol to be searched for. 7175e7992aSrie */ 7275e7992aSrie SLOOKUP_INIT(sl, 0, lmp, lmp, ld_entry_cnt, 0, 0, 0, 0, 0); 737c478bd9Sstevel@tonic-gate 747c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < max; cnt++, dip++) { 7508278a5eSRod Evans uint_t binfo; 7608278a5eSRod Evans Sresult sr; 7708278a5eSRod Evans 7808278a5eSRod Evans SRESULT_INIT(sr, NULL); 7908278a5eSRod Evans 807c478bd9Sstevel@tonic-gate if (((dip->di_flags & MSK_DI_FILTER) == 0) || 817c478bd9Sstevel@tonic-gate ((dip->di_flags & FLG_DI_AUXFLTR) && 827c478bd9Sstevel@tonic-gate (rtld_flags & RT_FL_NOAUXFLTR))) 837c478bd9Sstevel@tonic-gate continue; 8408278a5eSRod Evans (void) elf_lookup_filtee(&sl, &sr, &binfo, cnt, 8508278a5eSRod Evans in_nfavl); 867c478bd9Sstevel@tonic-gate } 877c478bd9Sstevel@tonic-gate } 887c478bd9Sstevel@tonic-gate } 897c478bd9Sstevel@tonic-gate 907c478bd9Sstevel@tonic-gate /* 917c478bd9Sstevel@tonic-gate * Analyze one or more link-maps of a link map control list. This routine is 927c478bd9Sstevel@tonic-gate * called at startup to continue the processing of the main executable. It is 937c478bd9Sstevel@tonic-gate * also called each time a new set of objects are loaded, ie. from filters, 947c478bd9Sstevel@tonic-gate * lazy-loaded objects, or dlopen(). 957c478bd9Sstevel@tonic-gate * 967c478bd9Sstevel@tonic-gate * In each instance we traverse the link-map control list starting with the 977c478bd9Sstevel@tonic-gate * initial object. As dependencies are analyzed they are added to the link-map 987c478bd9Sstevel@tonic-gate * control list. Thus the list grows as we traverse it - this results in the 997c478bd9Sstevel@tonic-gate * breadth first ordering of all needed objects. 10056deab07SRod Evans * 10156deab07SRod Evans * Return the initial link-map from which analysis starts for relocate_lmc(). 1027c478bd9Sstevel@tonic-gate */ 10356deab07SRod Evans Rt_map * 1042020b2b6SRod Evans analyze_lmc(Lm_list *lml, Aliste nlmco, Rt_map *nlmp, Rt_map *clmp, 1052020b2b6SRod Evans int *in_nfavl) 1067c478bd9Sstevel@tonic-gate { 10756deab07SRod Evans Rt_map *lmp; 1087c478bd9Sstevel@tonic-gate Lm_cntl *nlmc; 1097c478bd9Sstevel@tonic-gate 1107c478bd9Sstevel@tonic-gate /* 1117c478bd9Sstevel@tonic-gate * If this link-map control list is being analyzed, return. The object 1127c478bd9Sstevel@tonic-gate * that has just been added will be picked up by the existing analysis 1137c478bd9Sstevel@tonic-gate * thread. Note, this is only really meaningful during process init- 1147c478bd9Sstevel@tonic-gate * ialization, as objects are added to the main link-map control list. 1157c478bd9Sstevel@tonic-gate * Following this initialization, each family of objects that are loaded 1167c478bd9Sstevel@tonic-gate * are added to a new link-map control list. 1177c478bd9Sstevel@tonic-gate */ 1187c478bd9Sstevel@tonic-gate /* LINTED */ 119cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 1207c478bd9Sstevel@tonic-gate if (nlmc->lc_flags & LMC_FLG_ANALYZING) 12156deab07SRod Evans return (nlmp); 1227c478bd9Sstevel@tonic-gate 1237c478bd9Sstevel@tonic-gate /* 1247c478bd9Sstevel@tonic-gate * If this object doesn't belong to the present link-map control list 1257c478bd9Sstevel@tonic-gate * then it must already have been analyzed, or it is in the process of 1267c478bd9Sstevel@tonic-gate * being analyzed prior to us recursing into this analysis. In either 1277c478bd9Sstevel@tonic-gate * case, ignore the object as it's already being taken care of. 1287c478bd9Sstevel@tonic-gate */ 1297c478bd9Sstevel@tonic-gate if (nlmco != CNTL(nlmp)) 13056deab07SRod Evans return (nlmp); 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate nlmc->lc_flags |= LMC_FLG_ANALYZING; 1337c478bd9Sstevel@tonic-gate 13456deab07SRod Evans for (lmp = nlmp; lmp; lmp = NEXT_RT_MAP(lmp)) { 1357c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & 1367c478bd9Sstevel@tonic-gate (FLG_RT_ANALZING | FLG_RT_ANALYZED | FLG_RT_DELETE)) 1377c478bd9Sstevel@tonic-gate continue; 1387c478bd9Sstevel@tonic-gate 1397c478bd9Sstevel@tonic-gate /* 1407c478bd9Sstevel@tonic-gate * Indicate that analyzing is under way. 1417c478bd9Sstevel@tonic-gate */ 1427c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_ANALZING; 1437c478bd9Sstevel@tonic-gate 1447c478bd9Sstevel@tonic-gate /* 1457c478bd9Sstevel@tonic-gate * If this link map represents a relocatable object, then we 1467c478bd9Sstevel@tonic-gate * need to finish the link-editing of the object at this point. 1477c478bd9Sstevel@tonic-gate */ 1487c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_OBJECT) { 14956deab07SRod Evans Rt_map *olmp; 15056deab07SRod Evans 1512020b2b6SRod Evans if ((olmp = elf_obj_fini(lml, lmp, clmp, 1522020b2b6SRod Evans in_nfavl)) == NULL) { 1537c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) 1547c478bd9Sstevel@tonic-gate continue; 15556deab07SRod Evans nlmp = NULL; 1567c478bd9Sstevel@tonic-gate break; 1577c478bd9Sstevel@tonic-gate } 15856deab07SRod Evans 15956deab07SRod Evans /* 16056deab07SRod Evans * The original link-map that captured a relocatable 16156deab07SRod Evans * object is a temporary link-map, that basically acts 16256deab07SRod Evans * as a place holder in the link-map list. On 16356deab07SRod Evans * completion of relocatable object processing, a new 16456deab07SRod Evans * link-map is created, and switched with the place 16556deab07SRod Evans * holder. Therefore, reassign both the present 16656deab07SRod Evans * link-map pointer and the return link-map pointer. 16756deab07SRod Evans * The former resets this routines link-map processing, 16856deab07SRod Evans * while the latter provides for later functions, like 16956deab07SRod Evans * relocate_lmc(), to start processing from this new 17056deab07SRod Evans * link-map. 17156deab07SRod Evans */ 17256deab07SRod Evans if (nlmp == lmp) 17356deab07SRod Evans nlmp = olmp; 17456deab07SRod Evans lmp = olmp; 1757c478bd9Sstevel@tonic-gate } 1767c478bd9Sstevel@tonic-gate 1777c478bd9Sstevel@tonic-gate DBG_CALL(Dbg_file_analyze(lmp)); 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate /* 1807c478bd9Sstevel@tonic-gate * Establish any dependencies this object requires. 1817c478bd9Sstevel@tonic-gate */ 1829aa23310Srie if (LM_NEEDED(lmp)(lml, nlmco, lmp, in_nfavl) == 0) { 1837c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) 1847c478bd9Sstevel@tonic-gate continue; 18556deab07SRod Evans nlmp = NULL; 1867c478bd9Sstevel@tonic-gate break; 1877c478bd9Sstevel@tonic-gate } 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate FLAGS(lmp) &= ~FLG_RT_ANALZING; 1907c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_ANALYZED; 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate /* 1937c478bd9Sstevel@tonic-gate * If we're building a configuration file, determine if this 1947c478bd9Sstevel@tonic-gate * object is a filter and if so load its filtees. This 1957c478bd9Sstevel@tonic-gate * traversal is only necessary for crle(1), as typical use of 1967c478bd9Sstevel@tonic-gate * an object will load filters as part of relocation processing. 1977c478bd9Sstevel@tonic-gate */ 1987c478bd9Sstevel@tonic-gate if (MODE(nlmp) & RTLD_CONFGEN) 1999aa23310Srie load_filtees(lmp, in_nfavl); 2007c478bd9Sstevel@tonic-gate 2017c478bd9Sstevel@tonic-gate /* 2027c478bd9Sstevel@tonic-gate * If an interposer has been added, it will have been inserted 2037c478bd9Sstevel@tonic-gate * in the link-map before the link we're presently analyzing. 2047c478bd9Sstevel@tonic-gate * Break out of this analysis loop and return to the head of 2057c478bd9Sstevel@tonic-gate * the link-map control list to analyze the interposer. Note 2067c478bd9Sstevel@tonic-gate * that this rescan preserves the breadth first loading of 2077c478bd9Sstevel@tonic-gate * dependencies. 2087c478bd9Sstevel@tonic-gate */ 20924a6229eSrie /* LINTED */ 210cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 2117c478bd9Sstevel@tonic-gate if (nlmc->lc_flags & LMC_FLG_REANALYZE) { 2127c478bd9Sstevel@tonic-gate nlmc->lc_flags &= ~LMC_FLG_REANALYZE; 2137c478bd9Sstevel@tonic-gate lmp = nlmc->lc_head; 2147c478bd9Sstevel@tonic-gate } 2157c478bd9Sstevel@tonic-gate } 2167c478bd9Sstevel@tonic-gate 21724a6229eSrie /* LINTED */ 218cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 2197c478bd9Sstevel@tonic-gate nlmc->lc_flags &= ~LMC_FLG_ANALYZING; 2207c478bd9Sstevel@tonic-gate 22156deab07SRod Evans return (nlmp); 2227c478bd9Sstevel@tonic-gate } 2237c478bd9Sstevel@tonic-gate 2247c478bd9Sstevel@tonic-gate /* 225466e2a62Srie * Determine whether a symbol represents zero, .bss, bits. Most commonly this 226466e2a62Srie * function is used to determine whether the data for a copy relocation refers 227466e2a62Srie * to initialized data or .bss. If the data definition is within .bss, then the 228466e2a62Srie * data is zero filled, and as the copy destination within the executable is 229466e2a62Srie * .bss, we can skip copying zero's to zero's. 230466e2a62Srie * 231466e2a62Srie * However, if the defining object has MOVE data, it's .bss might contain 232466e2a62Srie * non-zero data, in which case copy the definition regardless. 233466e2a62Srie * 234466e2a62Srie * For backward compatibility copy relocation processing, this routine can be 235466e2a62Srie * used to determine precisely if a copy destination is a move record recipient. 2367c478bd9Sstevel@tonic-gate */ 2377c478bd9Sstevel@tonic-gate static int 238466e2a62Srie are_bits_zero(Rt_map *dlmp, Sym *dsym, int dest) 2397c478bd9Sstevel@tonic-gate { 24056deab07SRod Evans mmapobj_result_t *mpp; 2417c478bd9Sstevel@tonic-gate caddr_t daddr = (caddr_t)dsym->st_value; 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & FLG_RT_FIXED) == 0) 2447c478bd9Sstevel@tonic-gate daddr += ADDR(dlmp); 2457c478bd9Sstevel@tonic-gate 246466e2a62Srie /* 247466e2a62Srie * Determine the segment that contains the copy definition. Given that 248466e2a62Srie * the copy relocation records have already been captured and verified, 249466e2a62Srie * a segment must be found (but we add an escape clause never the less). 250466e2a62Srie */ 25156deab07SRod Evans if ((mpp = find_segment(daddr, dlmp)) == NULL) 2527c478bd9Sstevel@tonic-gate return (1); 253466e2a62Srie 254466e2a62Srie /* 255466e2a62Srie * If the definition is not within .bss, indicate this is not zero data. 256466e2a62Srie */ 25756deab07SRod Evans if (daddr < (mpp->mr_addr + mpp->mr_offset + mpp->mr_fsize)) 2587c478bd9Sstevel@tonic-gate return (0); 259466e2a62Srie 260466e2a62Srie /* 261466e2a62Srie * If the definition is within .bss, make sure the definition isn't the 262466e2a62Srie * recipient of a move record. Note, we don't precisely analyze whether 263466e2a62Srie * the address is a move record recipient, as the infrastructure to 264466e2a62Srie * prepare for, and carry out this analysis, is probably more costly 265466e2a62Srie * than just copying the bytes regardless. 266466e2a62Srie */ 267466e2a62Srie if ((FLAGS(dlmp) & FLG_RT_MOVE) == 0) 268466e2a62Srie return (1); 269466e2a62Srie 270466e2a62Srie /* 271466e2a62Srie * However, for backward compatibility copy relocation processing, we 272466e2a62Srie * can afford to work a little harder. Here, determine precisely 273466e2a62Srie * whether the destination in the executable is a move record recipient. 274466e2a62Srie * See comments in lookup_sym_interpose(), below. 275466e2a62Srie */ 276466e2a62Srie if (dest && is_move_data(daddr)) 277466e2a62Srie return (0); 278466e2a62Srie 279466e2a62Srie return (1); 2807c478bd9Sstevel@tonic-gate } 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate /* 2837c478bd9Sstevel@tonic-gate * Relocate an individual object. 2847c478bd9Sstevel@tonic-gate */ 2857c478bd9Sstevel@tonic-gate static int 2869aa23310Srie relocate_so(Lm_list *lml, Rt_map *lmp, int *relocated, int now, int *in_nfavl) 2877c478bd9Sstevel@tonic-gate { 28856deab07SRod Evans APlist *textrel = NULL; 28956deab07SRod Evans int ret = 1; 29056deab07SRod Evans 2917c478bd9Sstevel@tonic-gate /* 2927c478bd9Sstevel@tonic-gate * If we're running under ldd(1), and haven't been asked to trace any 2937c478bd9Sstevel@tonic-gate * warnings, skip any actual relocation processing. 2947c478bd9Sstevel@tonic-gate */ 2957c478bd9Sstevel@tonic-gate if (((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0) || 2967c478bd9Sstevel@tonic-gate (lml->lm_flags & LML_FLG_TRC_WARN)) { 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate if (relocated) 2997c478bd9Sstevel@tonic-gate (*relocated)++; 3007c478bd9Sstevel@tonic-gate 30156deab07SRod Evans if ((LM_RELOC(lmp)(lmp, now, in_nfavl, &textrel) == 0) && 3027c478bd9Sstevel@tonic-gate ((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0)) 30356deab07SRod Evans ret = 0; 30456deab07SRod Evans 30556deab07SRod Evans /* 30656deab07SRod Evans * Finally process any move data. Note, this is carried out 30756deab07SRod Evans * with ldd(1) under relocation processing too, as it can flush 30856deab07SRod Evans * out move errors, and enables lari(1) to provide a true 30956deab07SRod Evans * representation of the runtime bindings. 31056deab07SRod Evans */ 31156deab07SRod Evans if ((FLAGS(lmp) & FLG_RT_MOVE) && 31256deab07SRod Evans (move_data(lmp, &textrel) == 0) && 31356deab07SRod Evans ((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0)) 31456deab07SRod Evans ret = 0; 3157c478bd9Sstevel@tonic-gate } 31656deab07SRod Evans 31756deab07SRod Evans /* 31856deab07SRod Evans * If a text segment was write enabled to perform any relocations or 31956deab07SRod Evans * move records, then re-protect the segment by disabling writes. 32056deab07SRod Evans */ 32156deab07SRod Evans if (textrel) { 32256deab07SRod Evans mmapobj_result_t *mpp; 32356deab07SRod Evans Aliste idx; 32456deab07SRod Evans 32556deab07SRod Evans for (APLIST_TRAVERSE(textrel, idx, mpp)) 32656deab07SRod Evans (void) set_prot(lmp, mpp, 0); 32756deab07SRod Evans free(textrel); 32856deab07SRod Evans } 32956deab07SRod Evans 33056deab07SRod Evans return (ret); 3317c478bd9Sstevel@tonic-gate } 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate /* 3347c478bd9Sstevel@tonic-gate * Relocate the objects on a link-map control list. 3357c478bd9Sstevel@tonic-gate */ 3367c478bd9Sstevel@tonic-gate static int 33756deab07SRod Evans _relocate_lmc(Lm_list *lml, Aliste lmco, Rt_map *nlmp, int *relocated, 33856deab07SRod Evans int *in_nfavl) 3397c478bd9Sstevel@tonic-gate { 3407c478bd9Sstevel@tonic-gate Rt_map *lmp; 3417c478bd9Sstevel@tonic-gate 342cb511613SAli Bahrami for (lmp = nlmp; lmp; lmp = NEXT_RT_MAP(lmp)) { 3437c478bd9Sstevel@tonic-gate /* 3447c478bd9Sstevel@tonic-gate * If this object has already been relocated, we're done. If 3457c478bd9Sstevel@tonic-gate * this object is being deleted, skip it, there's probably a 3467c478bd9Sstevel@tonic-gate * relocation error somewhere that's causing this deletion. 3477c478bd9Sstevel@tonic-gate */ 3487c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & 3497c478bd9Sstevel@tonic-gate (FLG_RT_RELOCING | FLG_RT_RELOCED | FLG_RT_DELETE)) 3507c478bd9Sstevel@tonic-gate continue; 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate /* 3537c478bd9Sstevel@tonic-gate * Indicate that relocation processing is under way. 3547c478bd9Sstevel@tonic-gate */ 3557c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_RELOCING; 3567c478bd9Sstevel@tonic-gate 3577c478bd9Sstevel@tonic-gate /* 3587c478bd9Sstevel@tonic-gate * Relocate the object. 3597c478bd9Sstevel@tonic-gate */ 3609aa23310Srie if (relocate_so(lml, lmp, relocated, 0, in_nfavl) == 0) 3617c478bd9Sstevel@tonic-gate return (0); 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate /* 3647c478bd9Sstevel@tonic-gate * Indicate that the objects relocation is complete. 3657c478bd9Sstevel@tonic-gate */ 3667c478bd9Sstevel@tonic-gate FLAGS(lmp) &= ~FLG_RT_RELOCING; 3677c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_RELOCED; 3687c478bd9Sstevel@tonic-gate 3697c478bd9Sstevel@tonic-gate /* 37056deab07SRod Evans * If this object is being relocated on the main link-map list 37156deab07SRod Evans * indicate that this object's init is available for harvesting. 37256deab07SRod Evans * Objects that are being collected on other link-map lists 37356deab07SRod Evans * will have there init availability tagged when the objects 37456deab07SRod Evans * are move to the main link-map list (ie, after we know they, 37556deab07SRod Evans * and their dependencies, are fully relocated and ready for 37656deab07SRod Evans * use). 37756deab07SRod Evans * 37856deab07SRod Evans * Note, even under ldd(1) this init identification is necessary 37956deab07SRod Evans * for -i (tsort) gathering. 3807c478bd9Sstevel@tonic-gate */ 38156deab07SRod Evans if (lmco == ALIST_OFF_DATA) { 3827c478bd9Sstevel@tonic-gate lml->lm_init++; 383dffec89cSrie lml->lm_flags |= LML_FLG_OBJADDED; 384466e2a62Srie } 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate /* 3877c478bd9Sstevel@tonic-gate * Determine if this object is a filter, and if a load filter 3887c478bd9Sstevel@tonic-gate * flag is in effect, trigger the loading of all its filtees. 3897c478bd9Sstevel@tonic-gate */ 3909aa23310Srie load_filtees(lmp, in_nfavl); 3917c478bd9Sstevel@tonic-gate } 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate /* 3947c478bd9Sstevel@tonic-gate * Perform special copy relocations. These are only meaningful for 3957c478bd9Sstevel@tonic-gate * dynamic executables (fixed and head of their link-map list). If 3967c478bd9Sstevel@tonic-gate * this ever has to change then the infrastructure of COPY() has to 397cce0e03bSab196087 * change. Presently, a given link map can only have a receiver or 398cce0e03bSab196087 * supplier of copy data, so a union is used to overlap the storage 399cce0e03bSab196087 * for the COPY_R() and COPY_S() lists. These lists would need to 400cce0e03bSab196087 * be separated. 4017c478bd9Sstevel@tonic-gate */ 4027c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) & FLG_RT_FIXED) && (nlmp == LIST(nlmp)->lm_head) && 4037c478bd9Sstevel@tonic-gate (((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0) || 4047c478bd9Sstevel@tonic-gate (lml->lm_flags & LML_FLG_TRC_WARN))) { 405cce0e03bSab196087 Rt_map *lmp; 406cce0e03bSab196087 Aliste idx1; 4077c478bd9Sstevel@tonic-gate Word tracing; 4087c478bd9Sstevel@tonic-gate 40902ca3e02Srie #if defined(__i386) 4107c478bd9Sstevel@tonic-gate if (elf_copy_gen(nlmp) == 0) 4117c478bd9Sstevel@tonic-gate return (0); 4127c478bd9Sstevel@tonic-gate #endif 413cce0e03bSab196087 if (COPY_S(nlmp) == NULL) 4147c478bd9Sstevel@tonic-gate return (1); 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate if ((LIST(nlmp)->lm_flags & LML_FLG_TRC_ENABLE) && 4177c478bd9Sstevel@tonic-gate (((rtld_flags & RT_FL_SILENCERR) == 0) || 4187c478bd9Sstevel@tonic-gate (LIST(nlmp)->lm_flags & LML_FLG_TRC_VERBOSE))) 4197c478bd9Sstevel@tonic-gate tracing = 1; 4207c478bd9Sstevel@tonic-gate else 4217c478bd9Sstevel@tonic-gate tracing = 0; 4227c478bd9Sstevel@tonic-gate 4235aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 4247c478bd9Sstevel@tonic-gate 425cce0e03bSab196087 for (APLIST_TRAVERSE(COPY_S(nlmp), idx1, lmp)) { 4267c478bd9Sstevel@tonic-gate Rel_copy *rcp; 427cce0e03bSab196087 Aliste idx2; 4287c478bd9Sstevel@tonic-gate 429cce0e03bSab196087 for (ALIST_TRAVERSE(COPY_R(lmp), idx2, rcp)) { 4307c478bd9Sstevel@tonic-gate int zero; 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate /* 433466e2a62Srie * Only copy the data if the data is from 434466e2a62Srie * a non-zero definition (ie. not .bss). 4357c478bd9Sstevel@tonic-gate */ 436466e2a62Srie zero = are_bits_zero(rcp->r_dlmp, 437466e2a62Srie rcp->r_dsym, 0); 4385aefb655Srie DBG_CALL(Dbg_reloc_copy(rcp->r_dlmp, nlmp, 4395aefb655Srie rcp->r_name, zero)); 4407c478bd9Sstevel@tonic-gate if (zero) 4417c478bd9Sstevel@tonic-gate continue; 4427c478bd9Sstevel@tonic-gate 4437c478bd9Sstevel@tonic-gate (void) memcpy(rcp->r_radd, rcp->r_dadd, 4447c478bd9Sstevel@tonic-gate rcp->r_size); 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate if ((tracing == 0) || ((FLAGS1(rcp->r_dlmp) & 4477c478bd9Sstevel@tonic-gate FL1_RT_DISPREL) == 0)) 4487c478bd9Sstevel@tonic-gate continue; 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_REL_CPYDISP), 4517c478bd9Sstevel@tonic-gate demangle(rcp->r_name), NAME(rcp->r_dlmp)); 4527c478bd9Sstevel@tonic-gate } 4537c478bd9Sstevel@tonic-gate } 4547c478bd9Sstevel@tonic-gate 4555aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 4567c478bd9Sstevel@tonic-gate 457cce0e03bSab196087 free(COPY_S(nlmp)); 4582017c965SRod Evans COPY_S(nlmp) = NULL; 4597c478bd9Sstevel@tonic-gate } 4607c478bd9Sstevel@tonic-gate return (1); 4617c478bd9Sstevel@tonic-gate } 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate int 4649aa23310Srie relocate_lmc(Lm_list *lml, Aliste nlmco, Rt_map *clmp, Rt_map *nlmp, 4659aa23310Srie int *in_nfavl) 4667c478bd9Sstevel@tonic-gate { 4677c478bd9Sstevel@tonic-gate int lret = 1, pret = 1; 468cce0e03bSab196087 APlist *alp; 4697c478bd9Sstevel@tonic-gate Aliste plmco; 4707c478bd9Sstevel@tonic-gate Lm_cntl *plmc, *nlmc; 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate /* 4737c478bd9Sstevel@tonic-gate * If this link-map control list is being relocated, return. The object 4747c478bd9Sstevel@tonic-gate * that has just been added will be picked up by the existing relocation 4757c478bd9Sstevel@tonic-gate * thread. Note, this is only really meaningful during process init- 4767c478bd9Sstevel@tonic-gate * ialization, as objects are added to the main link-map control list. 4777c478bd9Sstevel@tonic-gate * Following this initialization, each family of objects that are loaded 4787c478bd9Sstevel@tonic-gate * are added to a new link-map control list. 4797c478bd9Sstevel@tonic-gate */ 4807c478bd9Sstevel@tonic-gate /* LINTED */ 481cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate if (nlmc->lc_flags & LMC_FLG_RELOCATING) 4847c478bd9Sstevel@tonic-gate return (1); 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate nlmc->lc_flags |= LMC_FLG_RELOCATING; 4877c478bd9Sstevel@tonic-gate 4887c478bd9Sstevel@tonic-gate /* 4897c478bd9Sstevel@tonic-gate * Relocate one or more link-maps of a link map control list. If this 4907c478bd9Sstevel@tonic-gate * object doesn't belong to the present link-map control list then it 4917c478bd9Sstevel@tonic-gate * must already have been relocated, or it is in the process of being 4927c478bd9Sstevel@tonic-gate * relocated prior to us recursing into this relocation. In either 4937c478bd9Sstevel@tonic-gate * case, ignore the object as it's already being taken care of, however, 4947c478bd9Sstevel@tonic-gate * fall through and capture any relocation promotions that might have 4957c478bd9Sstevel@tonic-gate * been established from the reference mode of this object. 4967c478bd9Sstevel@tonic-gate * 4977c478bd9Sstevel@tonic-gate * If we're generating a configuration file using crle(1), two passes 4987c478bd9Sstevel@tonic-gate * may be involved. Under the first pass, RTLD_CONFGEN is set. Under 4997c478bd9Sstevel@tonic-gate * this pass, crle() loads objects into the process address space. No 5007c478bd9Sstevel@tonic-gate * relocation is necessary at this point, we simply need to analyze the 50108278a5eSRod Evans * objects to ensure any directly bound dependencies, filtees, etc. 50208278a5eSRod Evans * get loaded. Although we skip the relocation, fall through to ensure 5037c478bd9Sstevel@tonic-gate * any control lists are maintained appropriately. 5047c478bd9Sstevel@tonic-gate * 5057c478bd9Sstevel@tonic-gate * If objects are to be dldump(3c)'ed, crle(1) makes a second pass, 5067c478bd9Sstevel@tonic-gate * using RTLD_NOW and RTLD_CONFGEN. The RTLD_NOW effectively carries 5077c478bd9Sstevel@tonic-gate * out the relocations of all loaded objects. 5087c478bd9Sstevel@tonic-gate */ 5097c478bd9Sstevel@tonic-gate if ((nlmco == CNTL(nlmp)) && 5107c478bd9Sstevel@tonic-gate ((MODE(nlmp) & (RTLD_NOW | RTLD_CONFGEN)) != RTLD_CONFGEN)) { 5117c478bd9Sstevel@tonic-gate int relocated = 0; 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate /* 5147c478bd9Sstevel@tonic-gate * Determine whether the initial link-map control list has 5157c478bd9Sstevel@tonic-gate * started relocation. From this point, should any interposing 5167c478bd9Sstevel@tonic-gate * objects be added to this link-map control list, the objects 5177c478bd9Sstevel@tonic-gate * are demoted to standard objects. Their interposition can't 5187c478bd9Sstevel@tonic-gate * be guaranteed once relocations have been carried out. 5197c478bd9Sstevel@tonic-gate */ 520cce0e03bSab196087 if (nlmco == ALIST_OFF_DATA) 5217c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_STARTREL; 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate /* 52402ca3e02Srie * Relocate the link-map control list. Should this relocation 52502ca3e02Srie * fail, clean up this link-map list. Relocations within this 52602ca3e02Srie * list may have required relocation promotions on other lists, 52702ca3e02Srie * so before acting upon these, and possibly adding more objects 52802ca3e02Srie * to the present link-map control list, try and clean up any 52902ca3e02Srie * failed objects now. 5307c478bd9Sstevel@tonic-gate */ 53156deab07SRod Evans lret = _relocate_lmc(lml, nlmco, nlmp, &relocated, in_nfavl); 532cce0e03bSab196087 if ((lret == 0) && (nlmco != ALIST_OFF_DATA)) 533481bba9eSRod Evans remove_lmc(lml, clmp, nlmco, NAME(nlmp)); 5347c478bd9Sstevel@tonic-gate } 5357c478bd9Sstevel@tonic-gate 5367c478bd9Sstevel@tonic-gate /* 5377c478bd9Sstevel@tonic-gate * Determine the new, and previous link-map control lists. 5387c478bd9Sstevel@tonic-gate */ 53924a6229eSrie /* LINTED */ 540cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 541cce0e03bSab196087 if (nlmco == ALIST_OFF_DATA) { 5426679fdc0Srie plmco = nlmco; 5437c478bd9Sstevel@tonic-gate plmc = nlmc; 5446679fdc0Srie } else { 5457c478bd9Sstevel@tonic-gate plmco = nlmco - lml->lm_lists->al_size; 5467c478bd9Sstevel@tonic-gate /* LINTED */ 547cce0e03bSab196087 plmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, plmco); 5487c478bd9Sstevel@tonic-gate } 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate /* 5517c478bd9Sstevel@tonic-gate * Having completed this control list of objects, they can now be bound 5527c478bd9Sstevel@tonic-gate * to from other objects. Move this control list to the control list 5537c478bd9Sstevel@tonic-gate * that precedes it. Although this control list may have only bound to 5547c478bd9Sstevel@tonic-gate * controls lists much higher up the control list stack, it must only 5557c478bd9Sstevel@tonic-gate * be moved up one control list so as to preserve the link-map order 5567c478bd9Sstevel@tonic-gate * that may have already been traversed in search of symbols. 5577c478bd9Sstevel@tonic-gate */ 558cce0e03bSab196087 if (lret && (nlmco != ALIST_OFF_DATA) && nlmc->lc_head) 5597c478bd9Sstevel@tonic-gate lm_move(lml, nlmco, plmco, nlmc, plmc); 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate /* 5627c478bd9Sstevel@tonic-gate * Determine whether existing objects that have already been relocated, 5637c478bd9Sstevel@tonic-gate * need any additional relocations performed. This can occur when new 5647c478bd9Sstevel@tonic-gate * objects are loaded with RTLD_NOW, and these new objects have 5657c478bd9Sstevel@tonic-gate * dependencies on objects that are already loaded. Note, that we peel 5667c478bd9Sstevel@tonic-gate * any relocation promotions off of one control list at a time. This 5677c478bd9Sstevel@tonic-gate * prevents relocations from being bound to objects that might yet fail 5687c478bd9Sstevel@tonic-gate * to relocate themselves. 5697c478bd9Sstevel@tonic-gate */ 570cce0e03bSab196087 while ((alp = plmc->lc_now) != NULL) { 571cce0e03bSab196087 Aliste idx; 572cce0e03bSab196087 Rt_map *lmp; 5737c478bd9Sstevel@tonic-gate 5747c478bd9Sstevel@tonic-gate /* 5757c478bd9Sstevel@tonic-gate * Remove the relocation promotion list, as performing more 5767c478bd9Sstevel@tonic-gate * relocations may result in discovering more objects that need 5777c478bd9Sstevel@tonic-gate * promotion. 5787c478bd9Sstevel@tonic-gate */ 579cce0e03bSab196087 plmc->lc_now = NULL; 5807c478bd9Sstevel@tonic-gate 581cce0e03bSab196087 for (APLIST_TRAVERSE(alp, idx, lmp)) { 5827c478bd9Sstevel@tonic-gate /* 5837c478bd9Sstevel@tonic-gate * If the original relocation of the link-map control 5847c478bd9Sstevel@tonic-gate * list failed, or one of the relocation promotions of 5857c478bd9Sstevel@tonic-gate * this loop has failed, demote any pending objects 5867c478bd9Sstevel@tonic-gate * relocation mode. 5877c478bd9Sstevel@tonic-gate */ 5887c478bd9Sstevel@tonic-gate if ((lret == 0) || (pret == 0)) { 5897c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_NOW; 5907c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_LAZY; 5917c478bd9Sstevel@tonic-gate continue; 5927c478bd9Sstevel@tonic-gate } 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate /* 5957c478bd9Sstevel@tonic-gate * If a relocation fails, save the error condition. 5967c478bd9Sstevel@tonic-gate * It's possible that all new objects on the original 5977c478bd9Sstevel@tonic-gate * link-map control list have been relocated 5987c478bd9Sstevel@tonic-gate * successfully, but if the user request requires 5997c478bd9Sstevel@tonic-gate * promoting objects that have already been loaded, we 6007c478bd9Sstevel@tonic-gate * have to indicate that this operation couldn't be 6017c478bd9Sstevel@tonic-gate * performed. The unrelocated objects are in use on 6027c478bd9Sstevel@tonic-gate * another control list, and may continue to be used. 6037c478bd9Sstevel@tonic-gate * If the .plt that resulted in the error is called, 6047c478bd9Sstevel@tonic-gate * then the process will receive a fatal error at that 6057c478bd9Sstevel@tonic-gate * time. But, the .plt may never be called. 6067c478bd9Sstevel@tonic-gate */ 6079aa23310Srie if (relocate_so(lml, lmp, 0, 1, in_nfavl) == 0) 6087c478bd9Sstevel@tonic-gate pret = 0; 6097c478bd9Sstevel@tonic-gate } 6107c478bd9Sstevel@tonic-gate 6117c478bd9Sstevel@tonic-gate /* 6127c478bd9Sstevel@tonic-gate * Having promoted any objects, determine whether additional 6137c478bd9Sstevel@tonic-gate * dependencies were added, and if so move them to the previous 6147c478bd9Sstevel@tonic-gate * link-map control list. 6157c478bd9Sstevel@tonic-gate */ 61624a6229eSrie /* LINTED */ 617cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 61824a6229eSrie /* LINTED */ 619cce0e03bSab196087 plmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, plmco); 620cce0e03bSab196087 if ((nlmco != ALIST_OFF_DATA) && nlmc->lc_head) 6217c478bd9Sstevel@tonic-gate lm_move(lml, nlmco, plmco, nlmc, plmc); 6228521e5e6Srie free(alp); 6237c478bd9Sstevel@tonic-gate } 6247c478bd9Sstevel@tonic-gate 62524a6229eSrie /* 62602ca3e02Srie * If relocations have been successful, indicate that relocations are 62702ca3e02Srie * no longer active for this control list. Otherwise, leave the 62802ca3e02Srie * relocation flag, as this flag is used to determine the style of 62902ca3e02Srie * cleanup (see remove_lmc()). 63024a6229eSrie */ 63102ca3e02Srie if (lret && pret) { 63224a6229eSrie /* LINTED */ 633cce0e03bSab196087 nlmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, nlmco); 6347c478bd9Sstevel@tonic-gate nlmc->lc_flags &= ~LMC_FLG_RELOCATING; 6357c478bd9Sstevel@tonic-gate 6367c478bd9Sstevel@tonic-gate return (1); 63702ca3e02Srie } 63802ca3e02Srie 6397c478bd9Sstevel@tonic-gate return (0); 6407c478bd9Sstevel@tonic-gate } 6417c478bd9Sstevel@tonic-gate 6427c478bd9Sstevel@tonic-gate /* 6437c478bd9Sstevel@tonic-gate * Inherit the first rejection message for possible later diagnostics. 6447c478bd9Sstevel@tonic-gate * 6457c478bd9Sstevel@tonic-gate * Any attempt to process a file that is unsuccessful, should be accompanied 6467c478bd9Sstevel@tonic-gate * with an error diagnostic. However, some operations like searching for a 6477c478bd9Sstevel@tonic-gate * simple filename, involve trying numerous paths, and an error message for each 6487c478bd9Sstevel@tonic-gate * lookup is not required. Although a multiple search can fail, it's possible 6497c478bd9Sstevel@tonic-gate * that a file was found, but was rejected because it was the wrong type. 6507c478bd9Sstevel@tonic-gate * To satisfy these possibilities, the first failure is recorded as a rejection 6517c478bd9Sstevel@tonic-gate * message, and this message is used later for a more specific diagnostic. 6527c478bd9Sstevel@tonic-gate * 6537c478bd9Sstevel@tonic-gate * File searches are focused at load_one(), and from here a rejection descriptor 6547c478bd9Sstevel@tonic-gate * is passed down to various child routines. If these child routines can 6557c478bd9Sstevel@tonic-gate * process multiple files, then they will maintain their own rejection desc- 6567c478bd9Sstevel@tonic-gate * riptor. This is filled in for any failures, and a diagnostic produced to 6577c478bd9Sstevel@tonic-gate * reflect the failure. The child routines then employ rejection_inherit() to 6587c478bd9Sstevel@tonic-gate * pass the first rejection message back to load_one(). 6597c478bd9Sstevel@tonic-gate * 6607c478bd9Sstevel@tonic-gate * Note that the name, and rejection string must be duplicated, as the name 6617c478bd9Sstevel@tonic-gate * buffer and error string buffer (see conv_ routines) may be reused for 6627c478bd9Sstevel@tonic-gate * additional processing or rejection messages. 6637c478bd9Sstevel@tonic-gate */ 6647c478bd9Sstevel@tonic-gate void 66531fdd7caSab196087 rejection_inherit(Rej_desc *rej1, Rej_desc *rej2) 6667c478bd9Sstevel@tonic-gate { 6677c478bd9Sstevel@tonic-gate if (rej2->rej_type && (rej1->rej_type == 0)) { 6687c478bd9Sstevel@tonic-gate rej1->rej_type = rej2->rej_type; 6697c478bd9Sstevel@tonic-gate rej1->rej_info = rej2->rej_info; 67056deab07SRod Evans rej1->rej_flags = rej2->rej_flags; 6717c478bd9Sstevel@tonic-gate if (rej2->rej_name) 67256deab07SRod Evans rej1->rej_name = stravl_insert(rej2->rej_name, 0, 0, 0); 67356deab07SRod Evans if ((rej2->rej_str) && ((rej1->rej_str = 67456deab07SRod Evans stravl_insert(rej2->rej_str, 0, 0, 0)) == NULL)) 6757c478bd9Sstevel@tonic-gate rej1->rej_str = MSG_ORIG(MSG_EMG_ENOMEM); 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate } 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate /* 6800aa3cd4dSrie * Helper routine for is_so_matched() that consolidates matching a path name, 6810aa3cd4dSrie * or file name component of a link-map name. 6827c478bd9Sstevel@tonic-gate */ 68356deab07SRod Evans inline static int 6840aa3cd4dSrie _is_so_matched(const char *name, const char *str, int path) 6857c478bd9Sstevel@tonic-gate { 6867c478bd9Sstevel@tonic-gate const char *_str; 6877c478bd9Sstevel@tonic-gate 6880aa3cd4dSrie if ((path == 0) && ((_str = strrchr(str, '/')) != NULL)) 6897c478bd9Sstevel@tonic-gate _str++; 6907c478bd9Sstevel@tonic-gate else 6917c478bd9Sstevel@tonic-gate _str = str; 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate return (strcmp(name, _str)); 6947c478bd9Sstevel@tonic-gate } 6957c478bd9Sstevel@tonic-gate 6960aa3cd4dSrie /* 6970aa3cd4dSrie * Determine whether a search name matches one of the names associated with a 6980aa3cd4dSrie * link-map. A link-map contains several names: 6990aa3cd4dSrie * 7002017c965SRod Evans * - a NAME() - this is the basename of the dynamic executable that started 7012017c965SRod Evans * the process, and the path name of any dependencies used by the process. 7022017c965SRod Evans * Most executables are received as full path names, as exec() prepends a 7032017c965SRod Evans * search $PATH to locate the executable. However, simple file names can 7042017c965SRod Evans * be received from exec() if the file is executed from the present working 7052017c965SRod Evans * directory. Regardless, ld.so.1 maintains NAME() as the basename, as 7062017c965SRod Evans * this has always been the name used in diagnostics and error messages. 7072017c965SRod Evans * Most dependencies are full path names, as the typical search for a 7082017c965SRod Evans * dependency, say "libx.so.1", results in search paths being prepended to 7092017c965SRod Evans * the name, which eventually open "/lib/libx.so.1". However, relative 7102017c965SRod Evans * path names can be supplied as dependencies, e.g. dlopen("../libx.so.1"). 7110aa3cd4dSrie * 7122017c965SRod Evans * - a PATHNAME() - this is the fully resolved path name of the object. This 7132017c965SRod Evans * name will differ from NAME() for all dynamic executables, and may differ 7142017c965SRod Evans * from the NAME() of dependencies, if the dependency is not a full path 7152017c965SRod Evans * name, or the dependency resolves to a symbolic link. 7160aa3cd4dSrie * 7172017c965SRod Evans * - an ALIAS() name - these are alternative names by which the object has 71856deab07SRod Evans * been found, ie. when dependencies are loaded through a variety of 71956deab07SRod Evans * different symbolic links. 7200aa3cd4dSrie * 7210aa3cd4dSrie * The name pattern matching can differ depending on whether we are looking 7220aa3cd4dSrie * for a full path name (path != 0), or a simple file name (path == 0). Full 72356deab07SRod Evans * path names typically match NAME() or PATHNAME() entries. 7240aa3cd4dSrie * 7250aa3cd4dSrie * For all full path name searches, the link-map names are taken as is. For 7260aa3cd4dSrie * simple file name searches, only the file name component of any link-map 7270aa3cd4dSrie * names are used for comparison. 7280aa3cd4dSrie */ 72956deab07SRod Evans inline static Rt_map * 7300aa3cd4dSrie is_so_matched(Rt_map *lmp, const char *name, int path) 7317c478bd9Sstevel@tonic-gate { 732cce0e03bSab196087 Aliste idx; 733cce0e03bSab196087 const char *cp; 7347c478bd9Sstevel@tonic-gate 73556deab07SRod Evans if (_is_so_matched(name, NAME(lmp), path) == 0) 7367c478bd9Sstevel@tonic-gate return (lmp); 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate if (PATHNAME(lmp) != NAME(lmp)) { 73956deab07SRod Evans if (_is_so_matched(name, PATHNAME(lmp), path) == 0) 7407c478bd9Sstevel@tonic-gate return (lmp); 7417c478bd9Sstevel@tonic-gate } 7420aa3cd4dSrie 743cce0e03bSab196087 for (APLIST_TRAVERSE(ALIAS(lmp), idx, cp)) { 744cce0e03bSab196087 if (_is_so_matched(name, cp, path) == 0) 7450aa3cd4dSrie return (lmp); 7460aa3cd4dSrie } 7470aa3cd4dSrie 74837ffaf83SRod Evans return (NULL); 7497c478bd9Sstevel@tonic-gate } 7507c478bd9Sstevel@tonic-gate 7510aa3cd4dSrie /* 7520aa3cd4dSrie * Files are opened by ld.so.1 to satisfy dependencies, filtees and dlopen() 7530aa3cd4dSrie * requests. Each request investigates the file based upon the callers 7549aa23310Srie * environment. Once a full path name has been established, the following 7559aa23310Srie * checks are made: 7560aa3cd4dSrie * 7572017c965SRod Evans * - does the path exist in the link-map lists FullPathNode AVL tree? if 7589aa23310Srie * so, the file is already loaded, and its associated link-map pointer 7599aa23310Srie * is returned. 7602017c965SRod Evans * - does the path exist in the not-found AVL tree? if so, this path has 7619aa23310Srie * already been determined to not exist, and a failure is returned. 7622017c965SRod Evans * - a device/inode check, to ensure the same file isn't mapped multiple 7639aa23310Srie * times through different paths. See file_open(). 7649aa23310Srie * 7659aa23310Srie * However, there are cases where a test for an existing file name needs to be 7669aa23310Srie * carried out, such as dlopen(NOLOAD) requests, dldump() requests, and as a 7679aa23310Srie * final fallback to dependency loading. These requests are handled by 7689aa23310Srie * is_so_loaded(). 7690aa3cd4dSrie * 7700aa3cd4dSrie * A traversal through the callers link-map list is carried out, and from each 7710aa3cd4dSrie * link-map, a comparison is made against all of the various names by which the 77208278a5eSRod Evans * object has been referenced. is_so_matched() is used to compare the link-map 7739aa23310Srie * names against the name being searched for. Whether the search name is a full 7749aa23310Srie * path name or a simple file name, governs what comparisons are made. 7750aa3cd4dSrie * 7760aa3cd4dSrie * A full path name, which is a fully resolved path name that starts with a "/" 7770aa3cd4dSrie * character, or a relative path name that includes a "/" character, must match 77856deab07SRod Evans * the link-map names exactly. A simple file name, which is any name *not* 7790aa3cd4dSrie * containing a "/" character, are matched against the file name component of 7800aa3cd4dSrie * any link-map names. 7810aa3cd4dSrie */ 7827c478bd9Sstevel@tonic-gate Rt_map * 7839aa23310Srie is_so_loaded(Lm_list *lml, const char *name, int *in_nfavl) 7847c478bd9Sstevel@tonic-gate { 7857c478bd9Sstevel@tonic-gate Rt_map *lmp; 7867c478bd9Sstevel@tonic-gate avl_index_t where; 7877c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 788cce0e03bSab196087 Aliste idx; 7890aa3cd4dSrie int path = 0; 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate /* 7920aa3cd4dSrie * If the name is a full path name, first determine if the path name is 7939aa23310Srie * registered on the FullPathNode AVL, or not-found AVL trees. 7947c478bd9Sstevel@tonic-gate */ 7959aa23310Srie if (name[0] == '/') { 79656deab07SRod Evans uint_t hash = sgs_str_hash(name); 79756deab07SRod Evans 79856deab07SRod Evans if (((lmp = fpavl_recorded(lml, name, hash, &where)) != NULL) && 7997c478bd9Sstevel@tonic-gate ((FLAGS(lmp) & (FLG_RT_OBJECT | FLG_RT_DELETE)) == 0)) 8007c478bd9Sstevel@tonic-gate return (lmp); 80156deab07SRod Evans 80208278a5eSRod Evans if (pnavl_recorded(&nfavl, name, hash, NULL)) { 8039aa23310Srie /* 8049aa23310Srie * For dlopen() and dlsym() fall backs, indicate that 8059aa23310Srie * a registered not-found path has indicated that this 8069aa23310Srie * object does not exist. 8079aa23310Srie */ 8089aa23310Srie if (in_nfavl) 8099aa23310Srie (*in_nfavl)++; 81037ffaf83SRod Evans return (NULL); 8119aa23310Srie } 8129aa23310Srie } 8137c478bd9Sstevel@tonic-gate 8147c478bd9Sstevel@tonic-gate /* 8150aa3cd4dSrie * Determine whether the name is a simple file name, or a path name. 8167c478bd9Sstevel@tonic-gate */ 8170aa3cd4dSrie if (strchr(name, '/')) 8180aa3cd4dSrie path++; 8197c478bd9Sstevel@tonic-gate 8207c478bd9Sstevel@tonic-gate /* 8217c478bd9Sstevel@tonic-gate * Loop through the callers link-map lists. 8227c478bd9Sstevel@tonic-gate */ 823cce0e03bSab196087 for (ALIST_TRAVERSE(lml->lm_lists, idx, lmc)) { 824cb511613SAli Bahrami for (lmp = lmc->lc_head; lmp; lmp = NEXT_RT_MAP(lmp)) { 8257c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & (FLG_RT_OBJECT | FLG_RT_DELETE)) 8267c478bd9Sstevel@tonic-gate continue; 8277c478bd9Sstevel@tonic-gate 8280aa3cd4dSrie if (is_so_matched(lmp, name, path)) 8297c478bd9Sstevel@tonic-gate return (lmp); 8307c478bd9Sstevel@tonic-gate } 8317c478bd9Sstevel@tonic-gate } 83237ffaf83SRod Evans return (NULL); 8337c478bd9Sstevel@tonic-gate } 8347c478bd9Sstevel@tonic-gate 8357c478bd9Sstevel@tonic-gate /* 8367c478bd9Sstevel@tonic-gate * Tracing is enabled by the LD_TRACE_LOADED_OPTIONS environment variable which 8377c478bd9Sstevel@tonic-gate * is normally set from ldd(1). For each link map we load, print the load name 83808278a5eSRod Evans * and the full pathname of the associated object. 8397c478bd9Sstevel@tonic-gate */ 8407c478bd9Sstevel@tonic-gate /* ARGSUSED4 */ 8417c478bd9Sstevel@tonic-gate static void 8427c478bd9Sstevel@tonic-gate trace_so(Rt_map *clmp, Rej_desc *rej, const char *name, const char *path, 8437c478bd9Sstevel@tonic-gate int alter, const char *nfound) 8447c478bd9Sstevel@tonic-gate { 8457c478bd9Sstevel@tonic-gate const char *str = MSG_ORIG(MSG_STR_EMPTY); 8467c478bd9Sstevel@tonic-gate const char *reject = MSG_ORIG(MSG_STR_EMPTY); 8477c478bd9Sstevel@tonic-gate char _reject[PATH_MAX]; 8487c478bd9Sstevel@tonic-gate 8497c478bd9Sstevel@tonic-gate /* 8507c478bd9Sstevel@tonic-gate * The first time through trace_so() will only have lddstub on the 8517c478bd9Sstevel@tonic-gate * link-map list and the preloaded shared object is supplied as "path". 8527c478bd9Sstevel@tonic-gate * As we don't want to print this shared object as a dependency, but 8537c478bd9Sstevel@tonic-gate * instead inspect *its* dependencies, return. 8547c478bd9Sstevel@tonic-gate */ 8557c478bd9Sstevel@tonic-gate if (FLAGS1(clmp) & FL1_RT_LDDSTUB) 8567c478bd9Sstevel@tonic-gate return; 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate /* 8597c478bd9Sstevel@tonic-gate * Without any rejection info, this is a supplied not-found condition. 8607c478bd9Sstevel@tonic-gate */ 8617c478bd9Sstevel@tonic-gate if (rej && (rej->rej_type == 0)) { 8627c478bd9Sstevel@tonic-gate (void) printf(nfound, name); 8637c478bd9Sstevel@tonic-gate return; 8647c478bd9Sstevel@tonic-gate } 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate /* 8677c478bd9Sstevel@tonic-gate * If rejection information exists then establish what object was 8687c478bd9Sstevel@tonic-gate * found and the reason for its rejection. 8697c478bd9Sstevel@tonic-gate */ 8707c478bd9Sstevel@tonic-gate if (rej) { 871de777a60Sab196087 Conv_reject_desc_buf_t rej_buf; 872de777a60Sab196087 8737c478bd9Sstevel@tonic-gate /* LINTED */ 8747c478bd9Sstevel@tonic-gate (void) snprintf(_reject, PATH_MAX, 875de777a60Sab196087 MSG_INTL(ldd_reject[rej->rej_type]), 876ba2be530Sab196087 conv_reject_desc(rej, &rej_buf, M_MACH)); 8777c478bd9Sstevel@tonic-gate if (rej->rej_name) 8787c478bd9Sstevel@tonic-gate path = rej->rej_name; 8797c478bd9Sstevel@tonic-gate reject = (char *)_reject; 8807c478bd9Sstevel@tonic-gate 8817c478bd9Sstevel@tonic-gate /* 8827c478bd9Sstevel@tonic-gate * Was an alternative pathname defined (from a configuration 8837c478bd9Sstevel@tonic-gate * file). 8847c478bd9Sstevel@tonic-gate */ 88556deab07SRod Evans if (rej->rej_flags & FLG_REJ_ALTER) 8867c478bd9Sstevel@tonic-gate str = MSG_INTL(MSG_LDD_FIL_ALTER); 8877c478bd9Sstevel@tonic-gate } else { 8887c478bd9Sstevel@tonic-gate if (alter) 8897c478bd9Sstevel@tonic-gate str = MSG_INTL(MSG_LDD_FIL_ALTER); 8907c478bd9Sstevel@tonic-gate } 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate /* 8937c478bd9Sstevel@tonic-gate * If the load name isn't a full pathname print its associated pathname 8947c478bd9Sstevel@tonic-gate * together with all the other information we've gathered. 8957c478bd9Sstevel@tonic-gate */ 8967c478bd9Sstevel@tonic-gate if (*name == '/') 8977c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), path, str, reject); 8987c478bd9Sstevel@tonic-gate else 8997247f888Srie (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), name, path, str, 9007247f888Srie reject); 9017c478bd9Sstevel@tonic-gate } 9027c478bd9Sstevel@tonic-gate 9037c478bd9Sstevel@tonic-gate /* 9047c478bd9Sstevel@tonic-gate * Establish a link-map mode, initializing it if it has just been loaded, or 9057c478bd9Sstevel@tonic-gate * potentially updating it if it already exists. 9067c478bd9Sstevel@tonic-gate */ 9077c478bd9Sstevel@tonic-gate int 9087c478bd9Sstevel@tonic-gate update_mode(Rt_map *lmp, int omode, int nmode) 9097c478bd9Sstevel@tonic-gate { 910dffec89cSrie Lm_list *lml = LIST(lmp); 9117c478bd9Sstevel@tonic-gate int pmode = 0; 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate /* 9147c478bd9Sstevel@tonic-gate * A newly loaded object hasn't had its mode set yet. Modes are used to 9157c478bd9Sstevel@tonic-gate * load dependencies, so don't propagate any parent or no-load flags, as 9167c478bd9Sstevel@tonic-gate * these would adversely affect this objects ability to load any of its 9177c478bd9Sstevel@tonic-gate * dependencies that aren't already loaded. RTLD_FIRST is applicable to 9187c478bd9Sstevel@tonic-gate * this objects handle creation only, and should not be propagated. 9197c478bd9Sstevel@tonic-gate */ 9207c478bd9Sstevel@tonic-gate if ((FLAGS(lmp) & FLG_RT_MODESET) == 0) { 9217c478bd9Sstevel@tonic-gate MODE(lmp) |= nmode & ~(RTLD_PARENT | RTLD_NOLOAD | RTLD_FIRST); 9227c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_MODESET; 9237c478bd9Sstevel@tonic-gate return (1); 9247c478bd9Sstevel@tonic-gate } 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate /* 9277c478bd9Sstevel@tonic-gate * Establish any new overriding modes. RTLD_LAZY and RTLD_NOW should be 9287c478bd9Sstevel@tonic-gate * represented individually (this is historic, as these two flags were 9297c478bd9Sstevel@tonic-gate * the only flags originally available to dlopen()). Other flags are 9307c478bd9Sstevel@tonic-gate * accumulative, but have a hierarchy of preference. 9317c478bd9Sstevel@tonic-gate */ 9327c478bd9Sstevel@tonic-gate if ((omode & RTLD_LAZY) && (nmode & RTLD_NOW)) { 9337c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_LAZY; 9347c478bd9Sstevel@tonic-gate pmode |= RTLD_NOW; 9357c478bd9Sstevel@tonic-gate } 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate pmode |= ((~omode & nmode) & 9387c478bd9Sstevel@tonic-gate (RTLD_GLOBAL | RTLD_WORLD | RTLD_NODELETE)); 9397c478bd9Sstevel@tonic-gate if (pmode) { 9405aefb655Srie DBG_CALL(Dbg_file_mode_promote(lmp, pmode)); 9417c478bd9Sstevel@tonic-gate MODE(lmp) |= pmode; 9427c478bd9Sstevel@tonic-gate } 9437c478bd9Sstevel@tonic-gate 9447c478bd9Sstevel@tonic-gate /* 9457c478bd9Sstevel@tonic-gate * If this load is an RTLD_NOW request and the object has already been 9467c478bd9Sstevel@tonic-gate * loaded non-RTLD_NOW, append this object to the relocation-now list 9477c478bd9Sstevel@tonic-gate * of the objects associated control list. Note, if the object hasn't 9487c478bd9Sstevel@tonic-gate * yet been relocated, setting its MODE() to RTLD_NOW will establish 9497c478bd9Sstevel@tonic-gate * full relocation processing when it eventually gets relocated. 9507c478bd9Sstevel@tonic-gate */ 9517c478bd9Sstevel@tonic-gate if ((pmode & RTLD_NOW) && 9527c478bd9Sstevel@tonic-gate (FLAGS(lmp) & (FLG_RT_RELOCED | FLG_RT_RELOCING))) { 9537c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate /* LINTED */ 956cce0e03bSab196087 lmc = (Lm_cntl *)alist_item_by_offset(LIST(lmp)->lm_lists, 957cce0e03bSab196087 CNTL(lmp)); 958cce0e03bSab196087 (void) aplist_append(&lmc->lc_now, lmp, AL_CNT_LMNOW); 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate /* 962dffec89cSrie * If this objects .init has been collected but has not yet been called, 963dffec89cSrie * it may be necessary to reevaluate the object using tsort(). For 9647c478bd9Sstevel@tonic-gate * example, a new dlopen() hierarchy may bind to uninitialized objects 9657c478bd9Sstevel@tonic-gate * that are already loaded, or a dlopen(RTLD_NOW) can establish new 9667c478bd9Sstevel@tonic-gate * bindings between already loaded objects that require the tsort() 967dffec89cSrie * information be recomputed. If however, no new objects have been 968dffec89cSrie * added to the process, and this object hasn't been promoted, don't 969dffec89cSrie * bother reevaluating the .init. The present tsort() information is 970dffec89cSrie * probably as accurate as necessary, and by not establishing a parallel 971dffec89cSrie * tsort() we can help reduce the amount of recursion possible between 972dffec89cSrie * .inits. 9737c478bd9Sstevel@tonic-gate */ 974dffec89cSrie if (((FLAGS(lmp) & 975dffec89cSrie (FLG_RT_INITCLCT | FLG_RT_INITCALL)) == FLG_RT_INITCLCT) && 976dffec89cSrie ((lml->lm_flags & LML_FLG_OBJADDED) || ((pmode & RTLD_NOW) && 977dffec89cSrie (FLAGS(lmp) & (FLG_RT_RELOCED | FLG_RT_RELOCING))))) { 9787c478bd9Sstevel@tonic-gate FLAGS(lmp) &= ~FLG_RT_INITCLCT; 9797c478bd9Sstevel@tonic-gate LIST(lmp)->lm_init++; 980dffec89cSrie LIST(lmp)->lm_flags |= LML_FLG_OBJREEVAL; 9817c478bd9Sstevel@tonic-gate } 9827c478bd9Sstevel@tonic-gate 9837c478bd9Sstevel@tonic-gate return (pmode); 9847c478bd9Sstevel@tonic-gate } 9857c478bd9Sstevel@tonic-gate 9867c478bd9Sstevel@tonic-gate /* 9877c478bd9Sstevel@tonic-gate * Determine whether an alias name already exists, and if not create one. This 9887c478bd9Sstevel@tonic-gate * is typically used to retain dependency names, such as "libc.so.1", which 9897c478bd9Sstevel@tonic-gate * would have been expanded to full path names when they were loaded. The 99056deab07SRod Evans * full path names (NAME() and possibly PATHNAME()) are maintained on the 99156deab07SRod Evans * FullPathNode AVL tree, and thus would have been matched by fpavl_loaded() 99256deab07SRod Evans * during file_open(). 9937c478bd9Sstevel@tonic-gate */ 9947c478bd9Sstevel@tonic-gate int 9957c478bd9Sstevel@tonic-gate append_alias(Rt_map *lmp, const char *str, int *added) 9967c478bd9Sstevel@tonic-gate { 99756deab07SRod Evans const char *cp; 998cce0e03bSab196087 Aliste idx; 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate /* 10017c478bd9Sstevel@tonic-gate * Determine if this filename is already on the alias list. 10027c478bd9Sstevel@tonic-gate */ 1003cce0e03bSab196087 for (APLIST_TRAVERSE(ALIAS(lmp), idx, cp)) { 1004cce0e03bSab196087 if (strcmp(cp, str) == 0) 10057c478bd9Sstevel@tonic-gate return (1); 10067c478bd9Sstevel@tonic-gate } 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate /* 10097c478bd9Sstevel@tonic-gate * This is a new alias, append it to the alias list. 10107c478bd9Sstevel@tonic-gate */ 101156deab07SRod Evans if (((cp = stravl_insert(str, 0, 0, 0)) == NULL) || 101256deab07SRod Evans (aplist_append(&ALIAS(lmp), cp, AL_CNT_ALIAS) == NULL)) 10137c478bd9Sstevel@tonic-gate return (0); 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate if (added) 10167c478bd9Sstevel@tonic-gate *added = 1; 10177c478bd9Sstevel@tonic-gate return (1); 10187c478bd9Sstevel@tonic-gate } 10197c478bd9Sstevel@tonic-gate 10207c478bd9Sstevel@tonic-gate /* 10217c478bd9Sstevel@tonic-gate * Determine whether a file is already loaded by comparing device and inode 10227c478bd9Sstevel@tonic-gate * values. 10237c478bd9Sstevel@tonic-gate */ 10247c478bd9Sstevel@tonic-gate static Rt_map * 1025cb511613SAli Bahrami is_devinode_loaded(rtld_stat_t *status, Lm_list *lml, const char *name, 10267c478bd9Sstevel@tonic-gate uint_t flags) 10277c478bd9Sstevel@tonic-gate { 10287c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 1029cce0e03bSab196087 Aliste idx; 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate /* 10327c478bd9Sstevel@tonic-gate * If this is an auditor, it will have been opened on a new link-map. 10338af2c5b9Srie * To prevent multiple occurrences of the same auditor on multiple 10347c478bd9Sstevel@tonic-gate * link-maps, search the head of each link-map list and see if this 10357c478bd9Sstevel@tonic-gate * object is already loaded as an auditor. 10367c478bd9Sstevel@tonic-gate */ 10377c478bd9Sstevel@tonic-gate if (flags & FLG_RT_AUDIT) { 10387c478bd9Sstevel@tonic-gate Lm_list *lml; 10397c478bd9Sstevel@tonic-gate 104057ef7aa9SRod Evans for (APLIST_TRAVERSE(dynlm_list, idx, lml)) { 10417c478bd9Sstevel@tonic-gate Rt_map *nlmp = lml->lm_head; 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate if (nlmp && ((FLAGS(nlmp) & 10447c478bd9Sstevel@tonic-gate (FLG_RT_AUDIT | FLG_RT_DELETE)) == FLG_RT_AUDIT) && 10457c478bd9Sstevel@tonic-gate (STDEV(nlmp) == status->st_dev) && 10467c478bd9Sstevel@tonic-gate (STINO(nlmp) == status->st_ino)) 10477c478bd9Sstevel@tonic-gate return (nlmp); 10487c478bd9Sstevel@tonic-gate } 104937ffaf83SRod Evans return (NULL); 10507c478bd9Sstevel@tonic-gate } 10517c478bd9Sstevel@tonic-gate 10527c478bd9Sstevel@tonic-gate /* 10537c478bd9Sstevel@tonic-gate * If the file has been found determine from the new files status 10547c478bd9Sstevel@tonic-gate * information if this file is actually linked to one we already have 10557c478bd9Sstevel@tonic-gate * mapped. This catches symlink names not caught by is_so_loaded(). 10567c478bd9Sstevel@tonic-gate */ 1057cce0e03bSab196087 for (ALIST_TRAVERSE(lml->lm_lists, idx, lmc)) { 10587c478bd9Sstevel@tonic-gate Rt_map *nlmp; 10597c478bd9Sstevel@tonic-gate 1060cb511613SAli Bahrami for (nlmp = lmc->lc_head; nlmp; nlmp = NEXT_RT_MAP(nlmp)) { 10617c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) & FLG_RT_DELETE) || 10627c478bd9Sstevel@tonic-gate (FLAGS1(nlmp) & FL1_RT_LDDSTUB)) 10637c478bd9Sstevel@tonic-gate continue; 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate if ((STDEV(nlmp) != status->st_dev) || 10667c478bd9Sstevel@tonic-gate (STINO(nlmp) != status->st_ino)) 10677c478bd9Sstevel@tonic-gate continue; 10687c478bd9Sstevel@tonic-gate 10697c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_VERBOSE) { 10707247f888Srie /* BEGIN CSTYLED */ 10717c478bd9Sstevel@tonic-gate if (*name == '/') 10727c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), 10737c478bd9Sstevel@tonic-gate name, MSG_ORIG(MSG_STR_EMPTY), 10747c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 10757c478bd9Sstevel@tonic-gate else 10767c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), 10777c478bd9Sstevel@tonic-gate name, NAME(nlmp), 10787c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY), 10797c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 10807247f888Srie /* END CSTYLED */ 10817c478bd9Sstevel@tonic-gate } 10827c478bd9Sstevel@tonic-gate return (nlmp); 10837c478bd9Sstevel@tonic-gate } 10847c478bd9Sstevel@tonic-gate } 108537ffaf83SRod Evans return (NULL); 10867c478bd9Sstevel@tonic-gate } 10877c478bd9Sstevel@tonic-gate 10887c478bd9Sstevel@tonic-gate /* 10897c478bd9Sstevel@tonic-gate * Generate any error messages indicating a file could not be found. When 10907c478bd9Sstevel@tonic-gate * preloading or auditing a secure application, it can be a little more helpful 10917c478bd9Sstevel@tonic-gate * to indicate that a search of secure directories has failed, so adjust the 10927c478bd9Sstevel@tonic-gate * messages accordingly. 10937c478bd9Sstevel@tonic-gate */ 10947c478bd9Sstevel@tonic-gate void 10957c478bd9Sstevel@tonic-gate file_notfound(Lm_list *lml, const char *name, Rt_map *clmp, uint_t flags, 10967c478bd9Sstevel@tonic-gate Rej_desc *rej) 10977c478bd9Sstevel@tonic-gate { 10987c478bd9Sstevel@tonic-gate int secure = 0; 10997c478bd9Sstevel@tonic-gate 11007c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SECURE) && 11017c478bd9Sstevel@tonic-gate (flags & (FLG_RT_PRELOAD | FLG_RT_AUDIT))) 11027c478bd9Sstevel@tonic-gate secure++; 11037c478bd9Sstevel@tonic-gate 11047c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) { 11057c478bd9Sstevel@tonic-gate /* 11067c478bd9Sstevel@tonic-gate * Under ldd(1), auxiliary filtees that can't be loaded are 11077c478bd9Sstevel@tonic-gate * ignored, unless verbose errors are requested. 11087c478bd9Sstevel@tonic-gate */ 11097c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SILENCERR) && 11107c478bd9Sstevel@tonic-gate ((lml->lm_flags & LML_FLG_TRC_VERBOSE) == 0)) 11117c478bd9Sstevel@tonic-gate return; 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate if (secure) 11147c478bd9Sstevel@tonic-gate trace_so(clmp, rej, name, 0, 0, 11157c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_SEC_NFOUND)); 11167c478bd9Sstevel@tonic-gate else 11177c478bd9Sstevel@tonic-gate trace_so(clmp, rej, name, 0, 0, 11187c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_FIL_NFOUND)); 11197c478bd9Sstevel@tonic-gate return; 11207c478bd9Sstevel@tonic-gate } 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate if (rej->rej_type) { 1123de777a60Sab196087 Conv_reject_desc_buf_t rej_buf; 1124de777a60Sab196087 11255aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(err_reject[rej->rej_type]), 11267c478bd9Sstevel@tonic-gate rej->rej_name ? rej->rej_name : MSG_INTL(MSG_STR_UNKNOWN), 1127ba2be530Sab196087 conv_reject_desc(rej, &rej_buf, M_MACH)); 11287c478bd9Sstevel@tonic-gate return; 11297c478bd9Sstevel@tonic-gate } 11307c478bd9Sstevel@tonic-gate 11317c478bd9Sstevel@tonic-gate if (secure) 11325aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SEC_OPEN), name); 11337c478bd9Sstevel@tonic-gate else 11345aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), name, 11357c478bd9Sstevel@tonic-gate strerror(ENOENT)); 11367c478bd9Sstevel@tonic-gate } 11377c478bd9Sstevel@tonic-gate 11387c478bd9Sstevel@tonic-gate static int 113956deab07SRod Evans file_open(int err, Lm_list *lml, Rt_map *clmp, uint_t flags, Fdesc *fdp, 114056deab07SRod Evans Rej_desc *rej, int *in_nfavl) 11417c478bd9Sstevel@tonic-gate { 1142cb511613SAli Bahrami rtld_stat_t status; 11437c478bd9Sstevel@tonic-gate Rt_map *nlmp; 11449aa23310Srie avl_index_t nfavlwhere = 0; 114556deab07SRod Evans const char *oname = fdp->fd_oname, *nname = fdp->fd_nname; 114656deab07SRod Evans uint_t hash = sgs_str_hash(nname); 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate 114956deab07SRod Evans if ((nname = stravl_insert(fdp->fd_nname, hash, 0, 0)) == NULL) 115056deab07SRod Evans return (0); 115156deab07SRod Evans fdp->fd_nname = nname; 115256deab07SRod Evans 115356deab07SRod Evans if ((err == 0) && (fdp->fd_flags & FLG_FD_ALTER)) 11545aefb655Srie DBG_CALL(Dbg_file_config_obj(lml, oname, 0, nname)); 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate /* 11577c478bd9Sstevel@tonic-gate * If we're dealing with a full pathname, determine whether this 11587c478bd9Sstevel@tonic-gate * pathname is already known. Other pathnames fall through to the 11597c478bd9Sstevel@tonic-gate * dev/inode check, as even though the pathname may look the same as 11607c478bd9Sstevel@tonic-gate * one previously used, the process may have changed directory. 11617c478bd9Sstevel@tonic-gate */ 11627c478bd9Sstevel@tonic-gate if ((err == 0) && (nname[0] == '/')) { 116356deab07SRod Evans if ((nlmp = fpavl_recorded(lml, nname, hash, 116456deab07SRod Evans &(fdp->fd_avlwhere))) != NULL) { 116556deab07SRod Evans fdp->fd_lmp = nlmp; 11667c478bd9Sstevel@tonic-gate return (1); 11677c478bd9Sstevel@tonic-gate } 116808278a5eSRod Evans if (pnavl_recorded(&nfavl, nname, hash, &nfavlwhere)) { 11699aa23310Srie /* 11709aa23310Srie * For dlopen() and dlsym() fall backs, indicate that 11719aa23310Srie * a registered not-found path has indicated that this 11729aa23310Srie * object does not exist. If this path has been 117308278a5eSRod Evans * constructed as part of expanding a CAPABILITY 117408278a5eSRod Evans * directory, this is a silent failure, where no 117508278a5eSRod Evans * rejection message is created. 11769aa23310Srie */ 11779aa23310Srie if (in_nfavl) 11789aa23310Srie (*in_nfavl)++; 11799aa23310Srie return (0); 11809aa23310Srie } 11817c478bd9Sstevel@tonic-gate } 11827c478bd9Sstevel@tonic-gate 1183cb511613SAli Bahrami if ((err == 0) && ((rtld_stat(nname, &status)) != -1)) { 11847c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 11857c478bd9Sstevel@tonic-gate int fd, size, added; 11867c478bd9Sstevel@tonic-gate 11877c478bd9Sstevel@tonic-gate /* 11887c478bd9Sstevel@tonic-gate * If this path has been constructed as part of expanding a 118908278a5eSRod Evans * CAPABILITY directory, ignore any subdirectories. As this 119008278a5eSRod Evans * is a silent failure, no rejection message is created. For 119108278a5eSRod Evans * any other reference that expands to a directory, fall 119208278a5eSRod Evans * through to construct a meaningful rejection message. 11937c478bd9Sstevel@tonic-gate */ 119408278a5eSRod Evans if ((flags & FLG_RT_CAP) && 119556deab07SRod Evans ((status.st_mode & S_IFMT) == S_IFDIR)) 119656deab07SRod Evans return (0); 119756deab07SRod Evans 119856deab07SRod Evans /* 119956deab07SRod Evans * If this is a directory (which can't be mmap()'ed) generate a 120056deab07SRod Evans * precise error message. 120156deab07SRod Evans */ 120256deab07SRod Evans if ((status.st_mode & S_IFMT) == S_IFDIR) { 120356deab07SRod Evans rej->rej_name = nname; 120456deab07SRod Evans if (fdp->fd_flags & FLG_FD_ALTER) 120556deab07SRod Evans rej->rej_flags = FLG_REJ_ALTER; 120656deab07SRod Evans rej->rej_type = SGS_REJ_STR; 120756deab07SRod Evans rej->rej_str = strerror(EISDIR); 120856deab07SRod Evans DBG_CALL(Dbg_file_rejected(lml, rej, M_MACH)); 12097c478bd9Sstevel@tonic-gate return (0); 12108521e5e6Srie } 12117c478bd9Sstevel@tonic-gate 12127c478bd9Sstevel@tonic-gate /* 12137c478bd9Sstevel@tonic-gate * Resolve the filename and determine whether the resolved name 12147c478bd9Sstevel@tonic-gate * is already known. Typically, the previous fpavl_loaded() 12157c478bd9Sstevel@tonic-gate * will have caught this, as both NAME() and PATHNAME() for a 121656deab07SRod Evans * link-map are recorded in the FullPathNode AVL tree. However, 12177c478bd9Sstevel@tonic-gate * instances exist where a file can be replaced (loop-back 12187c478bd9Sstevel@tonic-gate * mounts, bfu, etc.), and reference is made to the original 12197c478bd9Sstevel@tonic-gate * file through a symbolic link. By checking the pathname here, 12207c478bd9Sstevel@tonic-gate * we don't fall through to the dev/inode check and conclude 12217c478bd9Sstevel@tonic-gate * that a new file should be loaded. 12227c478bd9Sstevel@tonic-gate */ 122356deab07SRod Evans if ((nname[0] == '/') && 12247c478bd9Sstevel@tonic-gate ((size = resolvepath(nname, path, (PATH_MAX - 1))) > 0)) { 12257c478bd9Sstevel@tonic-gate path[size] = '\0'; 12267c478bd9Sstevel@tonic-gate 122756deab07SRod Evans fdp->fd_flags |= FLG_FD_RESOLVED; 122856deab07SRod Evans 12297c478bd9Sstevel@tonic-gate if (strcmp(nname, path)) { 123024a6229eSrie if ((nlmp = 123156deab07SRod Evans fpavl_recorded(lml, path, 0, 0)) != NULL) { 12327c478bd9Sstevel@tonic-gate added = 0; 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate if (append_alias(nlmp, nname, 12357c478bd9Sstevel@tonic-gate &added) == 0) 12367c478bd9Sstevel@tonic-gate return (0); 12377247f888Srie /* BEGIN CSTYLED */ 12387c478bd9Sstevel@tonic-gate if (added) 123910a4fa49Srie DBG_CALL(Dbg_file_skip(LIST(clmp), 12405aefb655Srie NAME(nlmp), nname)); 12417247f888Srie /* END CSTYLED */ 124256deab07SRod Evans fdp->fd_lmp = nlmp; 12437c478bd9Sstevel@tonic-gate return (1); 12447c478bd9Sstevel@tonic-gate } 12457c478bd9Sstevel@tonic-gate 12467c478bd9Sstevel@tonic-gate /* 12477c478bd9Sstevel@tonic-gate * If this pathname hasn't been loaded, save 12487c478bd9Sstevel@tonic-gate * the resolved pathname so that it doesn't 12497c478bd9Sstevel@tonic-gate * have to be recomputed as part of fullpath() 12507c478bd9Sstevel@tonic-gate * processing. 12517c478bd9Sstevel@tonic-gate */ 125256deab07SRod Evans if ((fdp->fd_pname = stravl_insert(path, 0, 125356deab07SRod Evans (size + 1), 0)) == NULL) 12547c478bd9Sstevel@tonic-gate return (0); 12557c478bd9Sstevel@tonic-gate } 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate 12587c478bd9Sstevel@tonic-gate if (nlmp = is_devinode_loaded(&status, lml, nname, flags)) { 1259c75e1b9dSrie if (flags & FLG_RT_AUDIT) { 1260c75e1b9dSrie /* 1261c75e1b9dSrie * If we've been requested to load an auditor, 1262c75e1b9dSrie * and an auditor of the same name already 1263c75e1b9dSrie * exists, then the original auditor is used. 1264c75e1b9dSrie */ 1265c75e1b9dSrie DBG_CALL(Dbg_audit_skip(LIST(clmp), 1266c75e1b9dSrie NAME(nlmp), LIST(nlmp)->lm_lmidstr)); 1267c75e1b9dSrie } else { 1268c75e1b9dSrie /* 1269c75e1b9dSrie * Otherwise, if an alternatively named file 1270c75e1b9dSrie * has been found for the same dev/inode, add 127156deab07SRod Evans * a new name alias. Insert any alias full path 127256deab07SRod Evans * name in the FullPathNode AVL tree. 1273c75e1b9dSrie */ 12747c478bd9Sstevel@tonic-gate added = 0; 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate if (append_alias(nlmp, nname, &added) == 0) 12777c478bd9Sstevel@tonic-gate return (0); 12787c478bd9Sstevel@tonic-gate if (added) { 1279c75e1b9dSrie if ((nname[0] == '/') && 1280c75e1b9dSrie (fpavl_insert(lml, nlmp, 1281c75e1b9dSrie nname, 0) == 0)) 12827c478bd9Sstevel@tonic-gate return (0); 1283c75e1b9dSrie DBG_CALL(Dbg_file_skip(LIST(clmp), 1284c75e1b9dSrie NAME(nlmp), nname)); 12857c478bd9Sstevel@tonic-gate } 1286c75e1b9dSrie } 1287c75e1b9dSrie 1288c75e1b9dSrie /* 1289c75e1b9dSrie * Record in the file descriptor the existing object 1290c75e1b9dSrie * that satisfies this open request. 1291c75e1b9dSrie */ 129256deab07SRod Evans fdp->fd_lmp = nlmp; 12937c478bd9Sstevel@tonic-gate return (1); 12947c478bd9Sstevel@tonic-gate } 12957c478bd9Sstevel@tonic-gate 12967c478bd9Sstevel@tonic-gate if ((fd = open(nname, O_RDONLY, 0)) == -1) { 12977c478bd9Sstevel@tonic-gate /* 12987c478bd9Sstevel@tonic-gate * As the file must exist for the previous stat() to 12997c478bd9Sstevel@tonic-gate * have succeeded, record the error condition. 13007c478bd9Sstevel@tonic-gate */ 13017c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_STR; 13027c478bd9Sstevel@tonic-gate rej->rej_str = strerror(errno); 13037c478bd9Sstevel@tonic-gate } else { 130456deab07SRod Evans /* 130556deab07SRod Evans * Map the object. A successful return indicates that 130656deab07SRod Evans * the object is appropriate for ld.so.1 processing. 130756deab07SRod Evans */ 130856deab07SRod Evans fdp->fd_ftp = map_obj(lml, fdp, status.st_size, nname, 130956deab07SRod Evans fd, rej); 131056deab07SRod Evans (void) close(fd); 13117c478bd9Sstevel@tonic-gate 131256deab07SRod Evans if (fdp->fd_ftp != NULL) { 131356deab07SRod Evans fdp->fd_dev = status.st_dev; 131456deab07SRod Evans fdp->fd_ino = status.st_ino; 13157c478bd9Sstevel@tonic-gate return (1); 13167c478bd9Sstevel@tonic-gate } 13177c478bd9Sstevel@tonic-gate } 13187c478bd9Sstevel@tonic-gate 13197c478bd9Sstevel@tonic-gate } else if (errno != ENOENT) { 13207c478bd9Sstevel@tonic-gate /* 13217c478bd9Sstevel@tonic-gate * If the open() failed for anything other than the file not 13227c478bd9Sstevel@tonic-gate * existing, record the error condition. 13237c478bd9Sstevel@tonic-gate */ 13247c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_STR; 13257c478bd9Sstevel@tonic-gate rej->rej_str = strerror(errno); 13267c478bd9Sstevel@tonic-gate } 13277c478bd9Sstevel@tonic-gate 13287c478bd9Sstevel@tonic-gate /* 13299aa23310Srie * Regardless of error, duplicate and record any full path names that 13309aa23310Srie * can't be used on the "not-found" AVL tree. 13319aa23310Srie */ 133256deab07SRod Evans if (nname[0] == '/') 133356deab07SRod Evans nfavl_insert(nname, nfavlwhere); 13349aa23310Srie 13359aa23310Srie /* 13367c478bd9Sstevel@tonic-gate * Indicate any rejection. 13377c478bd9Sstevel@tonic-gate */ 13387c478bd9Sstevel@tonic-gate if (rej->rej_type) { 13397c478bd9Sstevel@tonic-gate rej->rej_name = nname; 134056deab07SRod Evans if (fdp->fd_flags & FLG_FD_ALTER) 134156deab07SRod Evans rej->rej_flags = FLG_REJ_ALTER; 1342ba2be530Sab196087 DBG_CALL(Dbg_file_rejected(lml, rej, M_MACH)); 13437c478bd9Sstevel@tonic-gate } 13447c478bd9Sstevel@tonic-gate return (0); 13457c478bd9Sstevel@tonic-gate } 13467c478bd9Sstevel@tonic-gate 13477c478bd9Sstevel@tonic-gate /* 13487c478bd9Sstevel@tonic-gate * Find a full pathname (it contains a "/"). 13497c478bd9Sstevel@tonic-gate */ 13507c478bd9Sstevel@tonic-gate int 135156deab07SRod Evans find_path(Lm_list *lml, Rt_map *clmp, uint_t flags, Fdesc *fdp, Rej_desc *rej, 135256deab07SRod Evans int *in_nfavl) 13537c478bd9Sstevel@tonic-gate { 135456deab07SRod Evans const char *oname = fdp->fd_oname; 13557c478bd9Sstevel@tonic-gate int err = 0; 13567c478bd9Sstevel@tonic-gate 13577c478bd9Sstevel@tonic-gate /* 13587c478bd9Sstevel@tonic-gate * If directory configuration exists determine if this path is known. 13597c478bd9Sstevel@tonic-gate */ 13607c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_DIRCFG) { 13617c478bd9Sstevel@tonic-gate Rtc_obj *obj; 13627c478bd9Sstevel@tonic-gate const char *aname; 13637c478bd9Sstevel@tonic-gate 13647c478bd9Sstevel@tonic-gate if ((obj = elf_config_ent(oname, (Word)elf_hash(oname), 13657c478bd9Sstevel@tonic-gate 0, &aname)) != 0) { 13667c478bd9Sstevel@tonic-gate /* 13677c478bd9Sstevel@tonic-gate * If the configuration file states that this path is a 13687c478bd9Sstevel@tonic-gate * directory, or the path is explicitly defined as 13697c478bd9Sstevel@tonic-gate * non-existent (ie. a unused platform specific 13707c478bd9Sstevel@tonic-gate * library), then go no further. 13717c478bd9Sstevel@tonic-gate */ 13727c478bd9Sstevel@tonic-gate if (obj->co_flags & RTC_OBJ_DIRENT) { 13737c478bd9Sstevel@tonic-gate err = EISDIR; 13747c478bd9Sstevel@tonic-gate } else if ((obj->co_flags & 13757c478bd9Sstevel@tonic-gate (RTC_OBJ_NOEXIST | RTC_OBJ_ALTER)) == 13767c478bd9Sstevel@tonic-gate RTC_OBJ_NOEXIST) { 13777c478bd9Sstevel@tonic-gate err = ENOENT; 13787c478bd9Sstevel@tonic-gate } else if ((obj->co_flags & RTC_OBJ_ALTER) && 13797c478bd9Sstevel@tonic-gate (rtld_flags & RT_FL_OBJALT) && (lml == &lml_main)) { 13807c478bd9Sstevel@tonic-gate int ret; 13817c478bd9Sstevel@tonic-gate 138256deab07SRod Evans fdp->fd_flags |= FLG_FD_ALTER; 138356deab07SRod Evans fdp->fd_nname = aname; 138456deab07SRod Evans 13857c478bd9Sstevel@tonic-gate /* 13867c478bd9Sstevel@tonic-gate * Attempt to open the alternative path. If 13877c478bd9Sstevel@tonic-gate * this fails, and the alternative is flagged 13887c478bd9Sstevel@tonic-gate * as optional, fall through to open the 13897c478bd9Sstevel@tonic-gate * original path. 13907c478bd9Sstevel@tonic-gate */ 13915aefb655Srie DBG_CALL(Dbg_libs_found(lml, aname, 13925aefb655Srie FLG_FD_ALTER)); 139356deab07SRod Evans ret = file_open(0, lml, clmp, flags, fdp, 139456deab07SRod Evans rej, in_nfavl); 139556deab07SRod Evans if (ret || ((obj->co_flags & 139656deab07SRod Evans RTC_OBJ_OPTINAL) == 0)) 13977c478bd9Sstevel@tonic-gate return (ret); 13987c478bd9Sstevel@tonic-gate 139956deab07SRod Evans fdp->fd_flags &= ~FLG_FD_ALTER; 14007c478bd9Sstevel@tonic-gate } 14017c478bd9Sstevel@tonic-gate } 14027c478bd9Sstevel@tonic-gate } 14035aefb655Srie DBG_CALL(Dbg_libs_found(lml, oname, 0)); 140456deab07SRod Evans fdp->fd_nname = oname; 140556deab07SRod Evans return (file_open(err, lml, clmp, flags, fdp, rej, in_nfavl)); 14067c478bd9Sstevel@tonic-gate } 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate /* 14097c478bd9Sstevel@tonic-gate * Find a simple filename (it doesn't contain a "/"). 14107c478bd9Sstevel@tonic-gate */ 14117c478bd9Sstevel@tonic-gate static int 141256deab07SRod Evans _find_file(Lm_list *lml, Rt_map *clmp, uint_t flags, Fdesc *fdp, Rej_desc *rej, 141356deab07SRod Evans Pdesc *pdp, int aflag, int *in_nfavl) 14147c478bd9Sstevel@tonic-gate { 141556deab07SRod Evans const char *nname = fdp->fd_nname; 141656deab07SRod Evans 14175aefb655Srie DBG_CALL(Dbg_libs_found(lml, nname, aflag)); 14187c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_TRC_SEARCH) && 14197c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) { 14207c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_PTH_TRYING), nname, aflag ? 14217c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_FIL_ALTER) : MSG_ORIG(MSG_STR_EMPTY)); 14227c478bd9Sstevel@tonic-gate } 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate /* 14257c478bd9Sstevel@tonic-gate * If we're being audited tell the audit library of the file we're about 14267c478bd9Sstevel@tonic-gate * to go search for. The audit library may offer an alternative 14277c478bd9Sstevel@tonic-gate * dependency, or indicate that this dependency should be ignored. 14287c478bd9Sstevel@tonic-gate */ 142956deab07SRod Evans if ((lml->lm_tflags | AFLAGS(clmp)) & LML_TFLG_AUD_OBJSEARCH) { 14309aa23310Srie char *aname; 14317c478bd9Sstevel@tonic-gate 14329aa23310Srie if ((aname = audit_objsearch(clmp, nname, 143356deab07SRod Evans (pdp->pd_flags & LA_SER_MASK))) == NULL) { 14347247f888Srie DBG_CALL(Dbg_audit_terminate(lml, nname)); 14357c478bd9Sstevel@tonic-gate return (0); 14367247f888Srie } 14377247f888Srie 143856deab07SRod Evans if (aname != nname) { 143956deab07SRod Evans fdp->fd_flags &= ~FLG_FD_SLASH; 144056deab07SRod Evans fdp->fd_nname = aname; 14417c478bd9Sstevel@tonic-gate } 144256deab07SRod Evans } 144356deab07SRod Evans return (file_open(0, lml, clmp, flags, fdp, rej, in_nfavl)); 14447c478bd9Sstevel@tonic-gate } 14457c478bd9Sstevel@tonic-gate 1446390b98b5Srie static int 144756deab07SRod Evans find_file(Lm_list *lml, Rt_map *clmp, uint_t flags, Fdesc *fdp, Rej_desc *rej, 144856deab07SRod Evans Pdesc *pdp, Word *strhash, int *in_nfavl) 14497c478bd9Sstevel@tonic-gate { 14507c478bd9Sstevel@tonic-gate static Rtc_obj Obj = { 0 }; 14517c478bd9Sstevel@tonic-gate Rtc_obj *dobj; 145256deab07SRod Evans const char *oname = fdp->fd_oname; 145356deab07SRod Evans size_t olen = strlen(oname); 14547c478bd9Sstevel@tonic-gate 145556deab07SRod Evans if (pdp->pd_pname == NULL) 14567c478bd9Sstevel@tonic-gate return (0); 145756deab07SRod Evans if (pdp->pd_info) { 145856deab07SRod Evans dobj = (Rtc_obj *)pdp->pd_info; 14597c478bd9Sstevel@tonic-gate if ((dobj->co_flags & 14607c478bd9Sstevel@tonic-gate (RTC_OBJ_NOEXIST | RTC_OBJ_ALTER)) == RTC_OBJ_NOEXIST) 14617c478bd9Sstevel@tonic-gate return (0); 14627c478bd9Sstevel@tonic-gate } else 146356deab07SRod Evans dobj = NULL; 14647c478bd9Sstevel@tonic-gate 14657c478bd9Sstevel@tonic-gate /* 14667c478bd9Sstevel@tonic-gate * If configuration information exists see if this directory/file 14677c478bd9Sstevel@tonic-gate * combination exists. 14687c478bd9Sstevel@tonic-gate */ 14697c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_DIRCFG) && 147056deab07SRod Evans ((dobj == NULL) || (dobj->co_id != 0))) { 14717c478bd9Sstevel@tonic-gate Rtc_obj *fobj; 147256deab07SRod Evans const char *aname = NULL; 14737c478bd9Sstevel@tonic-gate 14747c478bd9Sstevel@tonic-gate /* 147556deab07SRod Evans * If this object descriptor has not yet been searched for in 147656deab07SRod Evans * the configuration file go find it. 14777c478bd9Sstevel@tonic-gate */ 147856deab07SRod Evans if (dobj == NULL) { 147956deab07SRod Evans dobj = elf_config_ent(pdp->pd_pname, 148056deab07SRod Evans (Word)elf_hash(pdp->pd_pname), 0, 0); 148156deab07SRod Evans if (dobj == NULL) 14827c478bd9Sstevel@tonic-gate dobj = &Obj; 148356deab07SRod Evans pdp->pd_info = (void *)dobj; 14847c478bd9Sstevel@tonic-gate 14857c478bd9Sstevel@tonic-gate if ((dobj->co_flags & (RTC_OBJ_NOEXIST | 14867c478bd9Sstevel@tonic-gate RTC_OBJ_ALTER)) == RTC_OBJ_NOEXIST) 14877c478bd9Sstevel@tonic-gate return (0); 14887c478bd9Sstevel@tonic-gate } 14897c478bd9Sstevel@tonic-gate 14907c478bd9Sstevel@tonic-gate /* 14917c478bd9Sstevel@tonic-gate * If we found a directory search for the file. 14927c478bd9Sstevel@tonic-gate */ 14937c478bd9Sstevel@tonic-gate if (dobj->co_id != 0) { 149467d74cc3SToomas Soome if (*strhash == 0) 149556deab07SRod Evans *strhash = (Word)elf_hash(oname); 149656deab07SRod Evans fobj = elf_config_ent(oname, *strhash, 149756deab07SRod Evans dobj->co_id, &aname); 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate /* 15007c478bd9Sstevel@tonic-gate * If this object specifically does not exist, or the 15017c478bd9Sstevel@tonic-gate * object can't be found in a know-all-entries 15027c478bd9Sstevel@tonic-gate * directory, continue looking. If the object does 15037c478bd9Sstevel@tonic-gate * exist determine if an alternative object exists. 15047c478bd9Sstevel@tonic-gate */ 150556deab07SRod Evans if (fobj == NULL) { 15067c478bd9Sstevel@tonic-gate if (dobj->co_flags & RTC_OBJ_ALLENTS) 15077c478bd9Sstevel@tonic-gate return (0); 15087c478bd9Sstevel@tonic-gate } else { 15097c478bd9Sstevel@tonic-gate if ((fobj->co_flags & (RTC_OBJ_NOEXIST | 15107c478bd9Sstevel@tonic-gate RTC_OBJ_ALTER)) == RTC_OBJ_NOEXIST) 15117c478bd9Sstevel@tonic-gate return (0); 15127c478bd9Sstevel@tonic-gate 15137c478bd9Sstevel@tonic-gate if ((fobj->co_flags & RTC_OBJ_ALTER) && 15147c478bd9Sstevel@tonic-gate (rtld_flags & RT_FL_OBJALT) && 15157c478bd9Sstevel@tonic-gate (lml == &lml_main)) { 15167c478bd9Sstevel@tonic-gate int ret; 15177c478bd9Sstevel@tonic-gate 151856deab07SRod Evans fdp->fd_flags |= FLG_FD_ALTER; 151956deab07SRod Evans fdp->fd_nname = aname; 152056deab07SRod Evans 15217c478bd9Sstevel@tonic-gate /* 15227c478bd9Sstevel@tonic-gate * Attempt to open the alternative path. 15237c478bd9Sstevel@tonic-gate * If this fails, and the alternative is 15247c478bd9Sstevel@tonic-gate * flagged as optional, fall through to 15257c478bd9Sstevel@tonic-gate * open the original path. 15267c478bd9Sstevel@tonic-gate */ 152756deab07SRod Evans ret = _find_file(lml, clmp, flags, fdp, 152856deab07SRod Evans rej, pdp, 1, in_nfavl); 15297c478bd9Sstevel@tonic-gate if (ret || ((fobj->co_flags & 15307c478bd9Sstevel@tonic-gate RTC_OBJ_OPTINAL) == 0)) 15317c478bd9Sstevel@tonic-gate return (ret); 15327c478bd9Sstevel@tonic-gate 153356deab07SRod Evans fdp->fd_flags &= ~FLG_FD_ALTER; 15347c478bd9Sstevel@tonic-gate } 15357c478bd9Sstevel@tonic-gate } 15367c478bd9Sstevel@tonic-gate } 15377c478bd9Sstevel@tonic-gate } 15387c478bd9Sstevel@tonic-gate 15397c478bd9Sstevel@tonic-gate /* 15407c478bd9Sstevel@tonic-gate * Protect ourselves from building an invalid pathname. 15417c478bd9Sstevel@tonic-gate */ 154256deab07SRod Evans if ((olen + pdp->pd_plen + 1) >= PATH_MAX) { 154356deab07SRod Evans eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), oname, 15447c478bd9Sstevel@tonic-gate strerror(ENAMETOOLONG)); 15457c478bd9Sstevel@tonic-gate return (0); 15467c478bd9Sstevel@tonic-gate } 154756deab07SRod Evans if ((fdp->fd_nname = (LM_GET_SO(clmp)(pdp->pd_pname, oname, 154856deab07SRod Evans pdp->pd_plen, olen))) == NULL) 15497c478bd9Sstevel@tonic-gate return (0); 15507c478bd9Sstevel@tonic-gate 155156deab07SRod Evans return (_find_file(lml, clmp, flags, fdp, rej, pdp, 0, in_nfavl)); 155256deab07SRod Evans } 155356deab07SRod Evans 155456deab07SRod Evans static Fct *Vector[] = { 155556deab07SRod Evans &elf_fct, 155656deab07SRod Evans 0 155756deab07SRod Evans }; 155856deab07SRod Evans 155956deab07SRod Evans /* 156056deab07SRod Evans * Remap the first page of a file to provide a better diagnostic as to why 156156deab07SRod Evans * an mmapobj(2) operation on this file failed. Sadly, mmapobj(), and all 156256deab07SRod Evans * system calls for that matter, only pass back a generic failure in errno. 156356deab07SRod Evans * Hopefully one day this will be improved, but in the mean time we repeat 156456deab07SRod Evans * the kernels ELF verification to try and provide more detailed information. 156556deab07SRod Evans */ 156656deab07SRod Evans static int 156756deab07SRod Evans map_fail(Fdesc *fdp, size_t fsize, const char *name, int fd, Rej_desc *rej) 156856deab07SRod Evans { 156956deab07SRod Evans caddr_t addr; 157056deab07SRod Evans int vnum; 157156deab07SRod Evans size_t size; 157256deab07SRod Evans 157356deab07SRod Evans /* 157456deab07SRod Evans * Use the original file size to determine what to map, and catch the 157556deab07SRod Evans * obvious error of a zero sized file. 157656deab07SRod Evans */ 157756deab07SRod Evans if (fsize == 0) { 157856deab07SRod Evans rej->rej_type = SGS_REJ_UNKFILE; 157956deab07SRod Evans return (1); 158056deab07SRod Evans } else if (fsize < syspagsz) 158156deab07SRod Evans size = fsize; 158256deab07SRod Evans else 158356deab07SRod Evans size = syspagsz; 158456deab07SRod Evans 158556deab07SRod Evans if ((addr = mmap(0, size, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED) 158656deab07SRod Evans return (0); 158756deab07SRod Evans 158856deab07SRod Evans rej->rej_type = 0; 158956deab07SRod Evans 159056deab07SRod Evans /* 159156deab07SRod Evans * Validate the file against each supported file type. Should a 159256deab07SRod Evans * characteristic of the file be found invalid for this platform, a 159356deab07SRod Evans * rejection message will have been recorded. 159456deab07SRod Evans */ 159556deab07SRod Evans for (vnum = 0; Vector[vnum]; vnum++) { 159656deab07SRod Evans if (((Vector[vnum]->fct_verify_file)(addr, size, 159756deab07SRod Evans fdp, name, rej) == 0) && rej->rej_type) 159856deab07SRod Evans break; 159956deab07SRod Evans } 160056deab07SRod Evans 160156deab07SRod Evans /* 160256deab07SRod Evans * If no rejection message has been recorded, then this is simply an 160356deab07SRod Evans * unknown file type. 160456deab07SRod Evans */ 160556deab07SRod Evans if (rej->rej_type == 0) 160656deab07SRod Evans rej->rej_type = SGS_REJ_UNKFILE; 160756deab07SRod Evans 160856deab07SRod Evans (void) munmap(addr, size); 160956deab07SRod Evans return (1); 161056deab07SRod Evans } 161156deab07SRod Evans 161256deab07SRod Evans /* 161356deab07SRod Evans * Unmap a file. 161456deab07SRod Evans */ 161556deab07SRod Evans void 161656deab07SRod Evans unmap_obj(mmapobj_result_t *mpp, uint_t mapnum) 161756deab07SRod Evans { 161856deab07SRod Evans uint_t num; 161956deab07SRod Evans 162056deab07SRod Evans for (num = 0; num < mapnum; num++) { 162156deab07SRod Evans /* LINTED */ 162256deab07SRod Evans (void) munmap((void *)(uintptr_t)mpp[num].mr_addr, 162356deab07SRod Evans mpp[num].mr_msize); 162456deab07SRod Evans } 162520272c2eSAli Bahrami cnt_unmap++; 162656deab07SRod Evans } 162756deab07SRod Evans 162856deab07SRod Evans /* 162956deab07SRod Evans * Map a file. 163056deab07SRod Evans */ 163156deab07SRod Evans Fct * 163256deab07SRod Evans map_obj(Lm_list *lml, Fdesc *fdp, size_t fsize, const char *name, int fd, 163356deab07SRod Evans Rej_desc *rej) 163456deab07SRod Evans { 163556deab07SRod Evans static mmapobj_result_t *smpp = NULL; 163656deab07SRod Evans static uint_t smapnum; 163756deab07SRod Evans mmapobj_result_t *mpp; 163856deab07SRod Evans uint_t mnum, mapnum, mflags; 163956deab07SRod Evans void *padding; 164056deab07SRod Evans 164156deab07SRod Evans /* 164256deab07SRod Evans * Allocate an initial mapping array. The initial size should be large 164356deab07SRod Evans * enough to handle the normal ELF objects we come across. 164456deab07SRod Evans */ 164556deab07SRod Evans if (smpp == NULL) { 164656deab07SRod Evans smpp = malloc(sizeof (mmapobj_result_t) * MMAPFD_NUM); 164756deab07SRod Evans if (smpp == NULL) 164856deab07SRod Evans return (NULL); 164956deab07SRod Evans smapnum = MMAPFD_NUM; 165056deab07SRod Evans } 165156deab07SRod Evans 165256deab07SRod Evans /* 165356deab07SRod Evans * If object padding is required, set the necessary flags. 165456deab07SRod Evans */ 165556deab07SRod Evans if (r_debug.rtd_objpad) { 165656deab07SRod Evans mflags = MMOBJ_INTERPRET | MMOBJ_PADDING; 165756deab07SRod Evans padding = &r_debug.rtd_objpad; 165856deab07SRod Evans } else { 165956deab07SRod Evans mflags = MMOBJ_INTERPRET; 166056deab07SRod Evans padding = NULL; 166156deab07SRod Evans } 166256deab07SRod Evans 166356deab07SRod Evans /* 166456deab07SRod Evans * Map the file. If the number of mappings required by this file 166556deab07SRod Evans * exceeds the present mapping structure, an error indicating the 166656deab07SRod Evans * return data is too big is returned. Bail on any other error. 166756deab07SRod Evans */ 166856deab07SRod Evans mapnum = smapnum; 166956deab07SRod Evans if (mmapobj(fd, mflags, smpp, &mapnum, padding) == -1) { 167056deab07SRod Evans if (errno != E2BIG) { 167156deab07SRod Evans int err = errno; 167256deab07SRod Evans 167356deab07SRod Evans /* 167456deab07SRod Evans * An unsupported error indicates that there's something 167556deab07SRod Evans * incompatible with this ELF file, and the process that 167656deab07SRod Evans * is already running. Map the first page of the file 167756deab07SRod Evans * and see if we can generate a better error message. 167856deab07SRod Evans */ 167956deab07SRod Evans if ((errno == ENOTSUP) && map_fail(fdp, fsize, name, 168056deab07SRod Evans fd, rej)) 168156deab07SRod Evans return (NULL); 168256deab07SRod Evans 168356deab07SRod Evans rej->rej_type = SGS_REJ_STR; 168456deab07SRod Evans rej->rej_str = strerror(err); 168556deab07SRod Evans return (NULL); 168656deab07SRod Evans } 168756deab07SRod Evans 168856deab07SRod Evans /* 168956deab07SRod Evans * The mapping requirement exceeds the present mapping 169056deab07SRod Evans * structure, however the number of mapping required is 169156deab07SRod Evans * available in the mapping number. 169256deab07SRod Evans */ 169356deab07SRod Evans free((void *)smpp); 169456deab07SRod Evans if ((smpp = malloc(sizeof (mmapobj_result_t) * mapnum)) == NULL) 169556deab07SRod Evans return (NULL); 169656deab07SRod Evans smapnum = mapnum; 169756deab07SRod Evans 169856deab07SRod Evans /* 169956deab07SRod Evans * With the appropriate mapping structure, try the mapping 170056deab07SRod Evans * request again. 170156deab07SRod Evans */ 170256deab07SRod Evans if (mmapobj(fd, mflags, smpp, &mapnum, padding) == -1) { 170356deab07SRod Evans rej->rej_type = SGS_REJ_STR; 170456deab07SRod Evans rej->rej_str = strerror(errno); 170556deab07SRod Evans return (NULL); 170656deab07SRod Evans } 170756deab07SRod Evans } 170856deab07SRod Evans ASSERT(mapnum != 0); 170956deab07SRod Evans 171056deab07SRod Evans /* 171156deab07SRod Evans * Traverse the mappings in search of a file type ld.so.1 can process. 171256deab07SRod Evans * If the file type is verified as one ld.so.1 can process, retain the 171356deab07SRod Evans * mapping information, and the number of mappings this object uses, 171456deab07SRod Evans * and clear the static mapping pointer for the next map_obj() use of 171556deab07SRod Evans * mmapobj(). 171656deab07SRod Evans */ 171756deab07SRod Evans DBG_CALL(Dbg_file_mmapobj(lml, name, smpp, mapnum)); 171820272c2eSAli Bahrami cnt_map++; 171956deab07SRod Evans 172056deab07SRod Evans for (mnum = 0, mpp = smpp; mnum < mapnum; mnum++, mpp++) { 172156deab07SRod Evans uint_t flags = (mpp->mr_flags & MR_TYPE_MASK); 172256deab07SRod Evans Fct *fptr = NULL; 172356deab07SRod Evans 172456deab07SRod Evans if (flags == MR_HDR_ELF) { 172556deab07SRod Evans fptr = elf_verify((mpp->mr_addr + mpp->mr_offset), 172656deab07SRod Evans mpp->mr_fsize, fdp, name, rej); 172756deab07SRod Evans } 172856deab07SRod Evans if (fptr) { 172956deab07SRod Evans fdp->fd_mapn = mapnum; 173056deab07SRod Evans fdp->fd_mapp = smpp; 173156deab07SRod Evans 173256deab07SRod Evans smpp = NULL; 173356deab07SRod Evans 173456deab07SRod Evans return (fptr); 173556deab07SRod Evans } 173656deab07SRod Evans } 173756deab07SRod Evans 173856deab07SRod Evans /* 173956deab07SRod Evans * If the mapped file is inappropriate, indicate that the file type is 174056deab07SRod Evans * unknown, and free the mapping. 174156deab07SRod Evans */ 174256deab07SRod Evans if (rej->rej_type == 0) 174356deab07SRod Evans rej->rej_type = SGS_REJ_UNKFILE; 174456deab07SRod Evans unmap_obj(smpp, mapnum); 174556deab07SRod Evans 174656deab07SRod Evans return (NULL); 17477c478bd9Sstevel@tonic-gate } 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate /* 17507c478bd9Sstevel@tonic-gate * A unique file has been opened. Create a link-map to represent it, and 17517c478bd9Sstevel@tonic-gate * process the various names by which it can be referenced. 17527c478bd9Sstevel@tonic-gate */ 175356deab07SRod Evans Rt_map * 17542020b2b6SRod Evans load_file(Lm_list *lml, Aliste lmco, Rt_map *clmp, Fdesc *fdp, int *in_nfavl) 17557c478bd9Sstevel@tonic-gate { 175656deab07SRod Evans mmapobj_result_t *fpmpp = NULL, *fmpp = NULL, *lpmpp, *lmpp; 175756deab07SRod Evans mmapobj_result_t *hmpp, *mpp, *ompp = fdp->fd_mapp; 175856deab07SRod Evans uint_t mnum, omapnum = fdp->fd_mapn; 175956deab07SRod Evans const char *nname = fdp->fd_nname; 17607c478bd9Sstevel@tonic-gate Rt_map *nlmp; 176156deab07SRod Evans Ehdr *ehdr = NULL; 17627c478bd9Sstevel@tonic-gate 17637c478bd9Sstevel@tonic-gate /* 176456deab07SRod Evans * Traverse the mappings for the input file to capture generic mapping 176556deab07SRod Evans * information, and create a link-map to represent the file. 17667c478bd9Sstevel@tonic-gate */ 176756deab07SRod Evans for (mnum = 0, mpp = ompp; mnum < omapnum; mnum++, mpp++) { 176856deab07SRod Evans uint_t flags = (mpp->mr_flags & MR_TYPE_MASK); 17697c478bd9Sstevel@tonic-gate 17707c478bd9Sstevel@tonic-gate /* 177156deab07SRod Evans * Keep track of the first and last mappings that may include 177256deab07SRod Evans * padding. 17737c478bd9Sstevel@tonic-gate */ 177456deab07SRod Evans if (fpmpp == NULL) 177556deab07SRod Evans fpmpp = mpp; 177656deab07SRod Evans lpmpp = mpp; 17777c478bd9Sstevel@tonic-gate 177856deab07SRod Evans /* 177956deab07SRod Evans * Keep track of the first and last mappings that do not include 178056deab07SRod Evans * padding. 178156deab07SRod Evans */ 178256deab07SRod Evans if (flags != MR_PADDING) { 178356deab07SRod Evans if (fmpp == NULL) 178456deab07SRod Evans fmpp = mpp; 178556deab07SRod Evans lmpp = mpp; 178656deab07SRod Evans } 178756deab07SRod Evans if (flags == MR_HDR_ELF) { 178856deab07SRod Evans /* LINTED */ 178956deab07SRod Evans ehdr = (Ehdr *)(mpp->mr_addr + mpp->mr_offset); 179056deab07SRod Evans hmpp = mpp; 1791*fec04708SRichard Lowe } 179256deab07SRod Evans } 179356deab07SRod Evans 179456deab07SRod Evans /* 179556deab07SRod Evans * The only ELF files we can handle are ET_EXEC, ET_DYN, and ET_REL. 179656deab07SRod Evans * 179756deab07SRod Evans * ET_REL must be processed by ld(1) to create an in-memory ET_DYN. 179856deab07SRod Evans * The initial processing carried out by elf_obj_file() creates a 179956deab07SRod Evans * temporary link-map, that acts as a place holder, until the objects 180056deab07SRod Evans * processing is finished with elf_obj_fini(). 180156deab07SRod Evans */ 180256deab07SRod Evans if (ehdr && (ehdr->e_type == ET_REL)) { 18032020b2b6SRod Evans if ((nlmp = elf_obj_file(lml, lmco, clmp, nname, hmpp, ompp, 180456deab07SRod Evans omapnum)) == NULL) 180556deab07SRod Evans return (nlmp); 180656deab07SRod Evans } else { 180756deab07SRod Evans Addr addr; 180856deab07SRod Evans size_t msize; 180956deab07SRod Evans 181056deab07SRod Evans /* 181156deab07SRod Evans * The size of the total reservation, and the padding range, 181256deab07SRod Evans * are a historic artifact required by debuggers. Although 181356deab07SRod Evans * these values express the range of the associated mappings, 181456deab07SRod Evans * there can be holes between segments (in which small objects 181556deab07SRod Evans * could be mapped). Anyone who needs to verify offsets 181656deab07SRod Evans * against segments should analyze all the object mappings, 181756deab07SRod Evans * rather than relying on these address ranges. 181856deab07SRod Evans */ 181956deab07SRod Evans addr = (Addr)(hmpp->mr_addr + hmpp->mr_offset); 182056deab07SRod Evans msize = lmpp->mr_addr + lmpp->mr_msize - fmpp->mr_addr; 182156deab07SRod Evans 182256deab07SRod Evans if ((nlmp = ((fdp->fd_ftp)->fct_new_lmp)(lml, lmco, fdp, addr, 18232020b2b6SRod Evans msize, NULL, clmp, in_nfavl)) == NULL) 182437ffaf83SRod Evans return (NULL); 18257c478bd9Sstevel@tonic-gate 18267c478bd9Sstevel@tonic-gate /* 182756deab07SRod Evans * Save generic mapping information. 18287c478bd9Sstevel@tonic-gate */ 182956deab07SRod Evans MMAPS(nlmp) = ompp; 183056deab07SRod Evans MMAPCNT(nlmp) = omapnum; 183156deab07SRod Evans PADSTART(nlmp) = (ulong_t)fpmpp->mr_addr; 183256deab07SRod Evans PADIMLEN(nlmp) = lpmpp->mr_addr + lpmpp->mr_msize - 183356deab07SRod Evans fpmpp->mr_addr; 183456deab07SRod Evans } 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate /* 183756deab07SRod Evans * Save the dev/inode information for later comparisons, and identify 183856deab07SRod Evans * this as a new object. 18397c478bd9Sstevel@tonic-gate */ 184056deab07SRod Evans STDEV(nlmp) = fdp->fd_dev; 184156deab07SRod Evans STINO(nlmp) = fdp->fd_ino; 184256deab07SRod Evans FLAGS(nlmp) |= FLG_RT_NEWLOAD; 18437c478bd9Sstevel@tonic-gate 184456deab07SRod Evans /* 184556deab07SRod Evans * If this is ELF relocatable object, we're done for now. 184656deab07SRod Evans */ 184756deab07SRod Evans if (ehdr && (ehdr->e_type == ET_REL)) 184856deab07SRod Evans return (nlmp); 184956deab07SRod Evans 185056deab07SRod Evans /* 185156deab07SRod Evans * Insert the names of this link-map into the FullPathNode AVL tree. 185256deab07SRod Evans * Save both the NAME() and PATHNAME() if the names differ. 185356deab07SRod Evans */ 185456deab07SRod Evans (void) fullpath(nlmp, fdp); 185556deab07SRod Evans 185656deab07SRod Evans if ((NAME(nlmp)[0] == '/') && (fpavl_insert(lml, nlmp, NAME(nlmp), 185756deab07SRod Evans fdp->fd_avlwhere) == 0)) { 18582020b2b6SRod Evans remove_so(lml, nlmp, clmp); 185937ffaf83SRod Evans return (NULL); 18607c478bd9Sstevel@tonic-gate } 186156deab07SRod Evans if (((NAME(nlmp)[0] != '/') || (NAME(nlmp) != PATHNAME(nlmp))) && 18627c478bd9Sstevel@tonic-gate (fpavl_insert(lml, nlmp, PATHNAME(nlmp), 0) == 0)) { 18632020b2b6SRod Evans remove_so(lml, nlmp, clmp); 186437ffaf83SRod Evans return (NULL); 18657c478bd9Sstevel@tonic-gate } 18663dbfc803SRod Evans 18673dbfc803SRod Evans /* 186856deab07SRod Evans * If this is a secure application, record any full path name directory 186956deab07SRod Evans * in which this dependency has been found. This directory can be 187056deab07SRod Evans * deemed safe (as we've already found a dependency here). This 187156deab07SRod Evans * recording provides a fall-back should another objects $ORIGIN 187256deab07SRod Evans * definition expands to this directory, an expansion that would 187356deab07SRod Evans * ordinarily be deemed insecure. 18743dbfc803SRod Evans */ 18753dbfc803SRod Evans if (rtld_flags & RT_FL_SECURE) { 18763dbfc803SRod Evans if (NAME(nlmp)[0] == '/') 18773dbfc803SRod Evans spavl_insert(NAME(nlmp)); 18783dbfc803SRod Evans if ((NAME(nlmp) != PATHNAME(nlmp)) && 18793dbfc803SRod Evans (PATHNAME(nlmp)[0] == '/')) 18803dbfc803SRod Evans spavl_insert(PATHNAME(nlmp)); 18813dbfc803SRod Evans } 18827c478bd9Sstevel@tonic-gate 18837c478bd9Sstevel@tonic-gate /* 18847c478bd9Sstevel@tonic-gate * If we're processing an alternative object reset the original name 18857c478bd9Sstevel@tonic-gate * for possible $ORIGIN processing. 18867c478bd9Sstevel@tonic-gate */ 188756deab07SRod Evans if (fdp->fd_flags & FLG_FD_ALTER) { 188856deab07SRod Evans const char *odir, *ndir; 18897c478bd9Sstevel@tonic-gate size_t olen; 18907c478bd9Sstevel@tonic-gate 18917c478bd9Sstevel@tonic-gate FLAGS(nlmp) |= FLG_RT_ALTER; 18927c478bd9Sstevel@tonic-gate 18937c478bd9Sstevel@tonic-gate /* 18947c478bd9Sstevel@tonic-gate * If we were given a pathname containing a slash then the 18957c478bd9Sstevel@tonic-gate * original name is still in oname. Otherwise the original 18967c478bd9Sstevel@tonic-gate * directory is in dir->p_name (which is all we need for 18977c478bd9Sstevel@tonic-gate * $ORIGIN). 18987c478bd9Sstevel@tonic-gate */ 189956deab07SRod Evans if (fdp->fd_flags & FLG_FD_SLASH) { 19007c478bd9Sstevel@tonic-gate char *ofil; 19017c478bd9Sstevel@tonic-gate 190256deab07SRod Evans odir = fdp->fd_oname; 190356deab07SRod Evans ofil = strrchr(fdp->fd_oname, '/'); 19047c478bd9Sstevel@tonic-gate olen = ofil - odir + 1; 19057c478bd9Sstevel@tonic-gate } else { 190656deab07SRod Evans odir = fdp->fd_odir; 19077c478bd9Sstevel@tonic-gate olen = strlen(odir) + 1; 19087c478bd9Sstevel@tonic-gate } 190956deab07SRod Evans if ((ndir = stravl_insert(odir, 0, olen, 1)) == NULL) { 19102020b2b6SRod Evans remove_so(lml, nlmp, clmp); 191137ffaf83SRod Evans return (NULL); 19127c478bd9Sstevel@tonic-gate } 19137c478bd9Sstevel@tonic-gate ORIGNAME(nlmp) = ndir; 191456deab07SRod Evans DIRSZ(nlmp) = --olen; 19157c478bd9Sstevel@tonic-gate } 19167c478bd9Sstevel@tonic-gate 19177c478bd9Sstevel@tonic-gate return (nlmp); 19187c478bd9Sstevel@tonic-gate } 19197c478bd9Sstevel@tonic-gate 19207c478bd9Sstevel@tonic-gate /* 19217c478bd9Sstevel@tonic-gate * This function loads the named file and returns a pointer to its link map. 19227c478bd9Sstevel@tonic-gate * It is assumed that the caller has already checked that the file is not 19237c478bd9Sstevel@tonic-gate * already loaded before calling this function (refer is_so_loaded()). 19247c478bd9Sstevel@tonic-gate * Find and open the file, map it into memory, add it to the end of the list 19257c478bd9Sstevel@tonic-gate * of link maps and return a pointer to the new link map. Return 0 on error. 19267c478bd9Sstevel@tonic-gate */ 19277c478bd9Sstevel@tonic-gate static Rt_map * 192856deab07SRod Evans load_so(Lm_list *lml, Aliste lmco, Rt_map *clmp, uint_t flags, 192956deab07SRod Evans Fdesc *fdp, Rej_desc *rej, int *in_nfavl) 19307c478bd9Sstevel@tonic-gate { 193156deab07SRod Evans const char *oname = fdp->fd_oname; 193256deab07SRod Evans Pdesc *pdp; 19337c478bd9Sstevel@tonic-gate 19347c478bd9Sstevel@tonic-gate /* 193556deab07SRod Evans * If this path name hasn't already been identified as containing a 193656deab07SRod Evans * slash, check the path name. Most paths have been constructed 193756deab07SRod Evans * through appending a file name to a search path, and/or have been 193856deab07SRod Evans * inspected by expand(), and thus have a slash. However, we can 193956deab07SRod Evans * receive path names via auditors or configuration files, and thus 194056deab07SRod Evans * an evaluation here catches these instances. 19417c478bd9Sstevel@tonic-gate */ 194256deab07SRod Evans if ((fdp->fd_flags & FLG_FD_SLASH) == 0) { 19437c478bd9Sstevel@tonic-gate const char *str; 19447c478bd9Sstevel@tonic-gate 19457c478bd9Sstevel@tonic-gate for (str = oname; *str; str++) { 19467c478bd9Sstevel@tonic-gate if (*str == '/') { 194756deab07SRod Evans fdp->fd_flags |= FLG_FD_SLASH; 19487c478bd9Sstevel@tonic-gate break; 19497c478bd9Sstevel@tonic-gate } 19507c478bd9Sstevel@tonic-gate } 19517c478bd9Sstevel@tonic-gate } 19527c478bd9Sstevel@tonic-gate 19537c478bd9Sstevel@tonic-gate /* 19547c478bd9Sstevel@tonic-gate * If we are passed a 'null' link-map this means that this is the first 19557c478bd9Sstevel@tonic-gate * object to be loaded on this link-map list. In that case we set the 19567c478bd9Sstevel@tonic-gate * link-map to ld.so.1's link-map. 19577c478bd9Sstevel@tonic-gate * 19587c478bd9Sstevel@tonic-gate * This link-map is referenced to determine what lookup rules to use 19597c478bd9Sstevel@tonic-gate * when searching for files. By using ld.so.1's we are defaulting to 19607c478bd9Sstevel@tonic-gate * ELF look-up rules. 19617c478bd9Sstevel@tonic-gate * 19627c478bd9Sstevel@tonic-gate * Note: This case happens when loading the first object onto 19637c478bd9Sstevel@tonic-gate * the plt_tracing link-map. 19647c478bd9Sstevel@tonic-gate */ 19657c478bd9Sstevel@tonic-gate if (clmp == 0) 19667c478bd9Sstevel@tonic-gate clmp = lml_rtld.lm_head; 19677c478bd9Sstevel@tonic-gate 19687c478bd9Sstevel@tonic-gate /* 196908278a5eSRod Evans * If this path resulted from a $CAPABILITY specification, then the 197008278a5eSRod Evans * best capability object has already been establish, and is available 197108278a5eSRod Evans * in the calling file descriptor. Perform some minor book-keeping so 197208278a5eSRod Evans * that we can fall through into common code. 19737c478bd9Sstevel@tonic-gate */ 197408278a5eSRod Evans if (flags & FLG_RT_CAP) { 19757c478bd9Sstevel@tonic-gate /* 1976fb1354edSrie * If this object is already loaded, we're done. 19777c478bd9Sstevel@tonic-gate */ 197856deab07SRod Evans if (fdp->fd_lmp) 197956deab07SRod Evans return (fdp->fd_lmp); 19807c478bd9Sstevel@tonic-gate 19817c478bd9Sstevel@tonic-gate /* 19827c478bd9Sstevel@tonic-gate * Obtain the avl index for this object. 19837c478bd9Sstevel@tonic-gate */ 198456deab07SRod Evans (void) fpavl_recorded(lml, fdp->fd_nname, 0, 198556deab07SRod Evans &(fdp->fd_avlwhere)); 1986bbf522bdSrie 198756deab07SRod Evans } else if (fdp->fd_flags & FLG_FD_SLASH) { 19887c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 19897c478bd9Sstevel@tonic-gate 199056deab07SRod Evans if (find_path(lml, clmp, flags, fdp, &_rej, in_nfavl) == 0) { 199131fdd7caSab196087 rejection_inherit(rej, &_rej); 199237ffaf83SRod Evans return (NULL); 19937c478bd9Sstevel@tonic-gate } 19947c478bd9Sstevel@tonic-gate 19957c478bd9Sstevel@tonic-gate /* 19967c478bd9Sstevel@tonic-gate * If this object is already loaded, we're done. 19977c478bd9Sstevel@tonic-gate */ 199856deab07SRod Evans if (fdp->fd_lmp) 199956deab07SRod Evans return (fdp->fd_lmp); 20007c478bd9Sstevel@tonic-gate 20017c478bd9Sstevel@tonic-gate } else { 20027c478bd9Sstevel@tonic-gate /* 20037c478bd9Sstevel@tonic-gate * No '/' - for each directory on list, make a pathname using 20047c478bd9Sstevel@tonic-gate * that directory and filename and try to open that file. 20057c478bd9Sstevel@tonic-gate */ 200656deab07SRod Evans Spath_desc sd = { search_rules, NULL, 0 }; 20077c478bd9Sstevel@tonic-gate Word strhash = 0; 200856deab07SRod Evans int found = 0; 200956deab07SRod Evans 20107c478bd9Sstevel@tonic-gate /* 201156deab07SRod Evans * Traverse the search path lists, creating full pathnames and 201256deab07SRod Evans * attempt to load each path. 20137c478bd9Sstevel@tonic-gate */ 201456deab07SRod Evans for (pdp = get_next_dir(&sd, clmp, flags); pdp; 201556deab07SRod Evans pdp = get_next_dir(&sd, clmp, flags)) { 20167c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 201756deab07SRod Evans Fdesc fd = { 0 }; 20187c478bd9Sstevel@tonic-gate 20197c478bd9Sstevel@tonic-gate /* 20209aa23310Srie * Under debugging, duplicate path name entries are 20219aa23310Srie * tagged but remain part of the search path list so 20229aa23310Srie * that they can be diagnosed under "unused" processing. 20239aa23310Srie * Skip these entries, as this path would have already 20249aa23310Srie * been attempted. 20259aa23310Srie */ 202656deab07SRod Evans if (pdp->pd_flags & PD_FLG_DUPLICAT) 20279aa23310Srie continue; 20289aa23310Srie 202956deab07SRod Evans fd = *fdp; 203056deab07SRod Evans 20319aa23310Srie /* 20327c478bd9Sstevel@tonic-gate * Try and locate this file. Make sure to clean up 20337c478bd9Sstevel@tonic-gate * any rejection information should the file have 20347c478bd9Sstevel@tonic-gate * been found, but not appropriate. 20357c478bd9Sstevel@tonic-gate */ 203656deab07SRod Evans if (find_file(lml, clmp, flags, &fd, &_rej, pdp, 203756deab07SRod Evans &strhash, in_nfavl) == 0) { 203831fdd7caSab196087 rejection_inherit(rej, &_rej); 20397c478bd9Sstevel@tonic-gate continue; 20407c478bd9Sstevel@tonic-gate } 20417c478bd9Sstevel@tonic-gate 20427c478bd9Sstevel@tonic-gate /* 20439aa23310Srie * Indicate that this search path has been used. If 20449aa23310Srie * this is an LD_LIBRARY_PATH setting, ignore any use 20459aa23310Srie * by ld.so.1 itself. 20469aa23310Srie */ 204756deab07SRod Evans if (((pdp->pd_flags & LA_SER_LIBPATH) == 0) || 20489aa23310Srie ((lml->lm_flags & LML_FLG_RTLDLM) == 0)) 204956deab07SRod Evans pdp->pd_flags |= PD_FLG_USED; 20509aa23310Srie 20519aa23310Srie /* 20527c478bd9Sstevel@tonic-gate * If this object is already loaded, we're done. 20537c478bd9Sstevel@tonic-gate */ 205456deab07SRod Evans *fdp = fd; 205556deab07SRod Evans if (fdp->fd_lmp) 205656deab07SRod Evans return (fdp->fd_lmp); 20577c478bd9Sstevel@tonic-gate 205856deab07SRod Evans fdp->fd_odir = pdp->pd_pname; 205956deab07SRod Evans found = 1; 20607c478bd9Sstevel@tonic-gate break; 20617c478bd9Sstevel@tonic-gate } 20627c478bd9Sstevel@tonic-gate 20637c478bd9Sstevel@tonic-gate /* 20647c478bd9Sstevel@tonic-gate * If the file couldn't be loaded, do another comparison of 20657c478bd9Sstevel@tonic-gate * loaded files using just the basename. This catches folks 20667c478bd9Sstevel@tonic-gate * who may have loaded multiple full pathname files (possibly 20677c478bd9Sstevel@tonic-gate * from setxid applications) to satisfy dependency relationships 20687c478bd9Sstevel@tonic-gate * (i.e., a file might have a dependency on foo.so.1 which has 20697c478bd9Sstevel@tonic-gate * already been opened using its full pathname). 20707c478bd9Sstevel@tonic-gate */ 207156deab07SRod Evans if (found == 0) 20729aa23310Srie return (is_so_loaded(lml, oname, in_nfavl)); 20737c478bd9Sstevel@tonic-gate } 20747c478bd9Sstevel@tonic-gate 20757c478bd9Sstevel@tonic-gate /* 207608278a5eSRod Evans * Trace that this successfully opened file is about to be processed. 207708278a5eSRod Evans * Note, as part of processing a family of hardware capabilities filtees 207808278a5eSRod Evans * a number of candidates may have been opened and mapped to determine 207908278a5eSRod Evans * their capability requirements. At this point we've decided which 208008278a5eSRod Evans * of the candidates to use. 208108278a5eSRod Evans */ 208208278a5eSRod Evans if (lml->lm_flags & LML_FLG_TRC_ENABLE) { 208308278a5eSRod Evans trace_so(clmp, 0, fdp->fd_oname, fdp->fd_nname, 208408278a5eSRod Evans (fdp->fd_flags & FLG_FD_ALTER), 0); 208508278a5eSRod Evans } 208608278a5eSRod Evans 208708278a5eSRod Evans /* 208808278a5eSRod Evans * Finish mapping the file and return the link-map descriptor. 20897c478bd9Sstevel@tonic-gate */ 20902020b2b6SRod Evans return (load_file(lml, lmco, clmp, fdp, in_nfavl)); 20917c478bd9Sstevel@tonic-gate } 20927c478bd9Sstevel@tonic-gate 20937c478bd9Sstevel@tonic-gate /* 209456deab07SRod Evans * Trace an attempt to load an object, and seed the originating name. 20957c478bd9Sstevel@tonic-gate */ 209656deab07SRod Evans const char * 209756deab07SRod Evans load_trace(Lm_list *lml, Pdesc *pdp, Rt_map *clmp, Fdesc *fdp) 20987c478bd9Sstevel@tonic-gate { 209956deab07SRod Evans const char *name = pdp->pd_pname; 21007247f888Srie 21012020b2b6SRod Evans DBG_CALL(Dbg_libs_find(lml, name)); 21022020b2b6SRod Evans 21037c478bd9Sstevel@tonic-gate /* 21047c478bd9Sstevel@tonic-gate * First generate any ldd(1) diagnostics. 21057c478bd9Sstevel@tonic-gate */ 21067c478bd9Sstevel@tonic-gate if ((lml->lm_flags & (LML_FLG_TRC_VERBOSE | LML_FLG_TRC_SEARCH)) && 21077c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) 21087c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_FIL_FIND), name, NAME(clmp)); 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate /* 211156deab07SRod Evans * Propagate any knowledge of a slash within the path name. 211256deab07SRod Evans */ 211356deab07SRod Evans if (pdp->pd_flags & PD_FLG_PNSLASH) 211456deab07SRod Evans fdp->fd_flags |= FLG_FD_SLASH; 211556deab07SRod Evans 211656deab07SRod Evans /* 21172020b2b6SRod Evans * If we're being audited tell any audit libraries of the file we're 21187c478bd9Sstevel@tonic-gate * about to go search for. 21197c478bd9Sstevel@tonic-gate */ 21202020b2b6SRod Evans if (aud_activity || 21212020b2b6SRod Evans ((lml->lm_tflags | AFLAGS(clmp)) & LML_TFLG_AUD_ACTIVITY)) 21227c478bd9Sstevel@tonic-gate audit_activity(clmp, LA_ACT_ADD); 21237c478bd9Sstevel@tonic-gate 212456deab07SRod Evans if ((lml->lm_tflags | AFLAGS(clmp)) & LML_TFLG_AUD_OBJSEARCH) { 212556deab07SRod Evans char *aname; 21267c478bd9Sstevel@tonic-gate 21277c478bd9Sstevel@tonic-gate /* 21287c478bd9Sstevel@tonic-gate * The auditor can indicate that this object should be ignored. 21297c478bd9Sstevel@tonic-gate */ 213056deab07SRod Evans if ((aname = 213156deab07SRod Evans audit_objsearch(clmp, name, LA_SER_ORIG)) == NULL) { 21327247f888Srie DBG_CALL(Dbg_audit_terminate(lml, name)); 213356deab07SRod Evans return (NULL); 21347c478bd9Sstevel@tonic-gate } 21357c478bd9Sstevel@tonic-gate 21367247f888Srie if (name != aname) { 213756deab07SRod Evans fdp->fd_flags &= ~FLG_FD_SLASH; 213856deab07SRod Evans name = aname; 21397c478bd9Sstevel@tonic-gate } 21407c478bd9Sstevel@tonic-gate } 214156deab07SRod Evans fdp->fd_oname = name; 214256deab07SRod Evans return (name); 21437c478bd9Sstevel@tonic-gate } 21447c478bd9Sstevel@tonic-gate 21457c478bd9Sstevel@tonic-gate /* 21467c478bd9Sstevel@tonic-gate * Having loaded an object and created a link-map to describe it, finish 21477c478bd9Sstevel@tonic-gate * processing this stage, including verifying any versioning requirements, 21487c478bd9Sstevel@tonic-gate * updating the objects mode, creating a handle if necessary, and adding this 21497c478bd9Sstevel@tonic-gate * object to existing handles if required. 21507c478bd9Sstevel@tonic-gate */ 2151390b98b5Srie static int 21527c478bd9Sstevel@tonic-gate load_finish(Lm_list *lml, const char *name, Rt_map *clmp, int nmode, 21537c478bd9Sstevel@tonic-gate uint_t flags, Grp_hdl **hdl, Rt_map *nlmp) 21547c478bd9Sstevel@tonic-gate { 21552017c965SRod Evans Aliste idx1; 2156cce0e03bSab196087 Grp_hdl *ghp; 21577c478bd9Sstevel@tonic-gate int promote; 21582017c965SRod Evans uint_t rdflags; 21597c478bd9Sstevel@tonic-gate 21607c478bd9Sstevel@tonic-gate /* 21612017c965SRod Evans * If this dependency is associated with a required version ensure that 21627c478bd9Sstevel@tonic-gate * the version is present in the loaded file. 21637c478bd9Sstevel@tonic-gate */ 216456deab07SRod Evans if (((rtld_flags & RT_FL_NOVERSION) == 0) && THIS_IS_ELF(clmp) && 216556deab07SRod Evans VERNEED(clmp) && (elf_verify_vers(name, clmp, nlmp) == 0)) 21667c478bd9Sstevel@tonic-gate return (0); 21677c478bd9Sstevel@tonic-gate 21687c478bd9Sstevel@tonic-gate /* 21697c478bd9Sstevel@tonic-gate * If this object has indicated that it should be isolated as a group 21707c478bd9Sstevel@tonic-gate * (DT_FLAGS_1 contains DF_1_GROUP - object was built with -B group), 21717c478bd9Sstevel@tonic-gate * or if the callers direct bindings indicate it should be isolated as 21722017c965SRod Evans * a group (DYNINFO flags contains FLG_DI_GROUP - dependency following 21737c478bd9Sstevel@tonic-gate * -zgroupperm), establish the appropriate mode. 21747c478bd9Sstevel@tonic-gate * 21757c478bd9Sstevel@tonic-gate * The intent of an object defining itself as a group is to isolate the 21767c478bd9Sstevel@tonic-gate * relocation of the group within its own members, however, unless 21777c478bd9Sstevel@tonic-gate * opened through dlopen(), in which case we assume dlsym() will be used 21782017c965SRod Evans * to locate symbols in the new object, we still need to associate the 21792017c965SRod Evans * new object with the caller so that the caller can bind to this new 21802017c965SRod Evans * object. This is equivalent to a dlopen(RTLD_GROUP) and dlsym() 21812017c965SRod Evans * using the returned handle. 21827c478bd9Sstevel@tonic-gate */ 21837c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) | flags) & FLG_RT_SETGROUP) { 21847c478bd9Sstevel@tonic-gate nmode &= ~RTLD_WORLD; 21857c478bd9Sstevel@tonic-gate nmode |= RTLD_GROUP; 21867c478bd9Sstevel@tonic-gate 21877c478bd9Sstevel@tonic-gate /* 21882017c965SRod Evans * If the object wasn't explicitly dlopen()'ed, in which case a 21892017c965SRod Evans * handle would have been requested, associate the object with 21907c478bd9Sstevel@tonic-gate * the parent. 21917c478bd9Sstevel@tonic-gate */ 21922017c965SRod Evans if ((flags & FLG_RT_PUBHDL) == 0) 21937c478bd9Sstevel@tonic-gate nmode |= RTLD_PARENT; 21947c478bd9Sstevel@tonic-gate } 21957c478bd9Sstevel@tonic-gate 21967c478bd9Sstevel@tonic-gate /* 21977c478bd9Sstevel@tonic-gate * Establish new mode and flags. 21987c478bd9Sstevel@tonic-gate */ 21997c478bd9Sstevel@tonic-gate promote = update_mode(nlmp, MODE(nlmp), nmode); 22007c478bd9Sstevel@tonic-gate FLAGS(nlmp) |= flags; 22017c478bd9Sstevel@tonic-gate 22027c478bd9Sstevel@tonic-gate /* 22032017c965SRod Evans * Establish the flags for any referenced dependency descriptors 22042017c965SRod Evans * (Grp_desc). 22052017c965SRod Evans * 22062017c965SRod Evans * - The referenced object is available for dlsym(). 22072017c965SRod Evans * - The referenced object is available to relocate against. 22082017c965SRod Evans * - The referenced object should have it's dependencies 22092017c965SRod Evans * added to this handle 22102017c965SRod Evans */ 22112017c965SRod Evans rdflags = (GPD_DLSYM | GPD_RELOC | GPD_ADDEPS); 22122017c965SRod Evans 22132017c965SRod Evans /* 22147c478bd9Sstevel@tonic-gate * If we've been asked to establish a handle create one for this object. 22157c478bd9Sstevel@tonic-gate * Or, if this object has already been analyzed, but this reference 22162017c965SRod Evans * requires that the mode of the object be promoted, create a private 22177c478bd9Sstevel@tonic-gate * handle to propagate the new modes to all this objects dependencies. 22187c478bd9Sstevel@tonic-gate */ 22192017c965SRod Evans if ((FLAGS(nlmp) & (FLG_RT_PUBHDL | FLG_RT_PRIHDL)) || 22202017c965SRod Evans (promote && (FLAGS(nlmp) & FLG_RT_ANALYZED))) { 22212017c965SRod Evans uint_t oflags, hflags, cdflags = 0; 22227c478bd9Sstevel@tonic-gate 22238af2c5b9Srie /* 22248af2c5b9Srie * Establish any flags for the handle (Grp_hdl). 22258af2c5b9Srie * 22262017c965SRod Evans * - Public handles establish dependencies between objects 22272017c965SRod Evans * that must be taken into account when dlclose()'ing 22282017c965SRod Evans * objects. Private handles provide for collecting 22292017c965SRod Evans * dependencies, but do not affect dlclose(). Note that 22302017c965SRod Evans * a handle may already exist, but the public/private 22312017c965SRod Evans * state is set to trigger the required propagation of the 22322017c965SRod Evans * handle's flags and any dependency gathering. 22332017c965SRod Evans * - Use of the RTLD_FIRST flag indicates that only the first 22348af2c5b9Srie * dependency on the handle (the new object) can be used 22358af2c5b9Srie * to satisfy dlsym() requests. 22368af2c5b9Srie */ 22372017c965SRod Evans if (FLAGS(nlmp) & FLG_RT_PUBHDL) 22382017c965SRod Evans hflags = GPH_PUBLIC; 22392017c965SRod Evans else 22402017c965SRod Evans hflags = GPH_PRIVATE; 22412017c965SRod Evans 22427c478bd9Sstevel@tonic-gate if (nmode & RTLD_FIRST) 22432017c965SRod Evans hflags |= GPH_FIRST; 22448af2c5b9Srie 22458af2c5b9Srie /* 22468af2c5b9Srie * Establish the flags for this callers dependency descriptor 22478af2c5b9Srie * (Grp_desc). 22488af2c5b9Srie * 22492017c965SRod Evans * - The creation of a public handle creates a descriptor 22502017c965SRod Evans * for the referenced object and the caller (parent). 22518af2c5b9Srie * Typically, the handle is created for dlopen() or for 22522017c965SRod Evans * filtering. A private handle does not need to maintain 22532017c965SRod Evans * a descriptor to the parent. 22542017c965SRod Evans * - Use of the RTLD_PARENT flag indicates that the parent 22558af2c5b9Srie * can be relocated against. 22568af2c5b9Srie */ 22572017c965SRod Evans if (FLAGS(nlmp) & FLG_RT_PUBHDL) { 22582017c965SRod Evans cdflags |= GPD_PARENT; 22598af2c5b9Srie if (nmode & RTLD_PARENT) 22608af2c5b9Srie cdflags |= GPD_RELOC; 22612017c965SRod Evans } 22627c478bd9Sstevel@tonic-gate 22637c478bd9Sstevel@tonic-gate /* 22642017c965SRod Evans * Now that the handle flags have been established, remove any 22652017c965SRod Evans * handle definition from the referenced object so that the 22662017c965SRod Evans * definitions don't mistakenly get inherited by a dependency. 22677c478bd9Sstevel@tonic-gate */ 22687c478bd9Sstevel@tonic-gate oflags = FLAGS(nlmp); 22692017c965SRod Evans FLAGS(nlmp) &= ~(FLG_RT_PUBHDL | FLG_RT_PRIHDL); 22707c478bd9Sstevel@tonic-gate 22718af2c5b9Srie DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD)); 22722017c965SRod Evans if ((ghp = hdl_create(lml, nlmp, clmp, hflags, rdflags, 22732017c965SRod Evans cdflags)) == NULL) 22747c478bd9Sstevel@tonic-gate return (0); 22757c478bd9Sstevel@tonic-gate 22767c478bd9Sstevel@tonic-gate /* 22777c478bd9Sstevel@tonic-gate * Add any dependencies that are already loaded, to the handle. 22787c478bd9Sstevel@tonic-gate */ 227902ca3e02Srie if (hdl_initialize(ghp, nlmp, nmode, promote) == 0) 22807c478bd9Sstevel@tonic-gate return (0); 22817c478bd9Sstevel@tonic-gate 22827c478bd9Sstevel@tonic-gate if (hdl) 22837c478bd9Sstevel@tonic-gate *hdl = ghp; 22847c478bd9Sstevel@tonic-gate 22857c478bd9Sstevel@tonic-gate /* 22862017c965SRod Evans * If we were asked to create a public handle, we're done. 22878af2c5b9Srie * 22882017c965SRod Evans * If this is a private handle request, then the handle is left 22892017c965SRod Evans * intact with a GPH_PRIVATE identifier. This handle is a 22902017c965SRod Evans * convenience for processing the dependencies of this object, 22912017c965SRod Evans * but does not affect how this object might be dlclose()'d. 22922017c965SRod Evans * For a private handle, fall through to carry out any group 22932017c965SRod Evans * processing. 22948af2c5b9Srie */ 22952017c965SRod Evans if (oflags & FLG_RT_PUBHDL) 22962017c965SRod Evans return (1); 22977c478bd9Sstevel@tonic-gate } 22987c478bd9Sstevel@tonic-gate 22997c478bd9Sstevel@tonic-gate /* 23007c478bd9Sstevel@tonic-gate * If the caller isn't part of a group we're done. 23017c478bd9Sstevel@tonic-gate */ 2302cce0e03bSab196087 if (GROUPS(clmp) == NULL) 23037c478bd9Sstevel@tonic-gate return (1); 23047c478bd9Sstevel@tonic-gate 23057c478bd9Sstevel@tonic-gate /* 23067c478bd9Sstevel@tonic-gate * Determine if our caller is already associated with a handle, if so 23077c478bd9Sstevel@tonic-gate * we need to add this object to any handles that already exist. 23087c478bd9Sstevel@tonic-gate * Traverse the list of groups our caller is a member of and add this 23097c478bd9Sstevel@tonic-gate * new link-map to those groups. 23107c478bd9Sstevel@tonic-gate */ 23112017c965SRod Evans for (APLIST_TRAVERSE(GROUPS(clmp), idx1, ghp)) { 23122017c965SRod Evans Aliste idx2; 23137c478bd9Sstevel@tonic-gate Grp_desc *gdp; 23142017c965SRod Evans int ale; 2315cce0e03bSab196087 Rt_map *dlmp1; 2316cce0e03bSab196087 APlist *lmalp = NULL; 23177c478bd9Sstevel@tonic-gate 23182017c965SRod Evans DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD)); 23192017c965SRod Evans 23207c478bd9Sstevel@tonic-gate /* 23217c478bd9Sstevel@tonic-gate * If the caller doesn't indicate that its dependencies should 23227c478bd9Sstevel@tonic-gate * be added to a handle, ignore it. This case identifies a 23237c478bd9Sstevel@tonic-gate * parent of a dlopen(RTLD_PARENT) request. 23247c478bd9Sstevel@tonic-gate */ 23252017c965SRod Evans for (ALIST_TRAVERSE(ghp->gh_depends, idx2, gdp)) { 23267c478bd9Sstevel@tonic-gate if (gdp->gd_depend == clmp) 23277c478bd9Sstevel@tonic-gate break; 23287c478bd9Sstevel@tonic-gate } 23297c478bd9Sstevel@tonic-gate if ((gdp->gd_flags & GPD_ADDEPS) == 0) 23307c478bd9Sstevel@tonic-gate continue; 23317c478bd9Sstevel@tonic-gate 23322017c965SRod Evans if ((gdp = hdl_add(ghp, nlmp, rdflags, &ale)) == NULL) 23337c478bd9Sstevel@tonic-gate return (0); 23347c478bd9Sstevel@tonic-gate 23357c478bd9Sstevel@tonic-gate /* 23367c478bd9Sstevel@tonic-gate * If this member already exists then its dependencies will 23377c478bd9Sstevel@tonic-gate * have already been processed. 23387c478bd9Sstevel@tonic-gate */ 23392017c965SRod Evans if (ale == ALE_EXISTS) 23407c478bd9Sstevel@tonic-gate continue; 23417c478bd9Sstevel@tonic-gate 23427c478bd9Sstevel@tonic-gate /* 23437c478bd9Sstevel@tonic-gate * If the object we've added has just been opened, it will not 23447c478bd9Sstevel@tonic-gate * yet have been processed for its dependencies, these will be 23457c478bd9Sstevel@tonic-gate * added on later calls to load_one(). If it doesn't have any 23467c478bd9Sstevel@tonic-gate * dependencies we're also done. 23477c478bd9Sstevel@tonic-gate */ 23487c478bd9Sstevel@tonic-gate if (((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0) || 2349cce0e03bSab196087 (DEPENDS(nlmp) == NULL)) 23507c478bd9Sstevel@tonic-gate continue; 23517c478bd9Sstevel@tonic-gate 23527c478bd9Sstevel@tonic-gate /* 23537c478bd9Sstevel@tonic-gate * Otherwise, this object exists and has dependencies, so add 23547c478bd9Sstevel@tonic-gate * all of its dependencies to the handle were operating on. 23557c478bd9Sstevel@tonic-gate */ 235656deab07SRod Evans if (aplist_append(&lmalp, nlmp, AL_CNT_DEPCLCT) == NULL) 23577c478bd9Sstevel@tonic-gate return (0); 23587c478bd9Sstevel@tonic-gate 23592017c965SRod Evans for (APLIST_TRAVERSE(lmalp, idx2, dlmp1)) { 23602017c965SRod Evans Aliste idx3; 2361cce0e03bSab196087 Bnd_desc *bdp; 23627c478bd9Sstevel@tonic-gate 23637c478bd9Sstevel@tonic-gate /* 23647c478bd9Sstevel@tonic-gate * Add any dependencies of this dependency to the 23657c478bd9Sstevel@tonic-gate * dynamic dependency list so they can be further 23667c478bd9Sstevel@tonic-gate * processed. 23677c478bd9Sstevel@tonic-gate */ 23682017c965SRod Evans for (APLIST_TRAVERSE(DEPENDS(dlmp1), idx3, bdp)) { 23697c478bd9Sstevel@tonic-gate Rt_map *dlmp2 = bdp->b_depend; 23707c478bd9Sstevel@tonic-gate 23717c478bd9Sstevel@tonic-gate if ((bdp->b_flags & BND_NEEDED) == 0) 23727c478bd9Sstevel@tonic-gate continue; 23737c478bd9Sstevel@tonic-gate 2374cce0e03bSab196087 if (aplist_test(&lmalp, dlmp2, 23757c478bd9Sstevel@tonic-gate AL_CNT_DEPCLCT) == 0) { 23767c478bd9Sstevel@tonic-gate free(lmalp); 23777c478bd9Sstevel@tonic-gate return (0); 23787c478bd9Sstevel@tonic-gate } 23797c478bd9Sstevel@tonic-gate } 23807c478bd9Sstevel@tonic-gate 23817c478bd9Sstevel@tonic-gate if (nlmp == dlmp1) 23827c478bd9Sstevel@tonic-gate continue; 23837c478bd9Sstevel@tonic-gate 23842017c965SRod Evans if ((gdp = 23852017c965SRod Evans hdl_add(ghp, dlmp1, rdflags, &ale)) == NULL) { 23867c478bd9Sstevel@tonic-gate free(lmalp); 23877c478bd9Sstevel@tonic-gate return (0); 23887c478bd9Sstevel@tonic-gate } 238956deab07SRod Evans 2390e0e63816SRod Evans if (ale == ALE_CREATE) 2391e0e63816SRod Evans (void) update_mode(dlmp1, MODE(dlmp1), nmode); 239256deab07SRod Evans } 23937c478bd9Sstevel@tonic-gate free(lmalp); 23947c478bd9Sstevel@tonic-gate } 23957c478bd9Sstevel@tonic-gate return (1); 23967c478bd9Sstevel@tonic-gate } 23977c478bd9Sstevel@tonic-gate 23987c478bd9Sstevel@tonic-gate /* 23997c478bd9Sstevel@tonic-gate * The central routine for loading shared objects. Insures ldd() diagnostics, 24002020b2b6SRod Evans * handle creation, and any other related additions are all done in one place. 24017c478bd9Sstevel@tonic-gate */ 240256deab07SRod Evans Rt_map * 240356deab07SRod Evans load_path(Lm_list *lml, Aliste lmco, Rt_map *clmp, int nmode, uint_t flags, 240456deab07SRod Evans Grp_hdl **hdl, Fdesc *fdp, Rej_desc *rej, int *in_nfavl) 24057c478bd9Sstevel@tonic-gate { 240656deab07SRod Evans const char *name = fdp->fd_oname; 24077c478bd9Sstevel@tonic-gate Rt_map *nlmp; 24087c478bd9Sstevel@tonic-gate 24097c478bd9Sstevel@tonic-gate if ((nmode & RTLD_NOLOAD) == 0) { 2410e0e63816SRod Evans int oin_nfavl; 2411e0e63816SRod Evans 2412e0e63816SRod Evans /* 2413e0e63816SRod Evans * Keep track of the number of not-found loads. 2414e0e63816SRod Evans */ 2415e0e63816SRod Evans if (in_nfavl) 2416e0e63816SRod Evans oin_nfavl = *in_nfavl; 2417e0e63816SRod Evans 24187c478bd9Sstevel@tonic-gate /* 24197c478bd9Sstevel@tonic-gate * If this isn't a noload request attempt to load the file. 24207c478bd9Sstevel@tonic-gate */ 242156deab07SRod Evans if ((nlmp = load_so(lml, lmco, clmp, flags, fdp, rej, 242256deab07SRod Evans in_nfavl)) == NULL) 242337ffaf83SRod Evans return (NULL); 24247c478bd9Sstevel@tonic-gate 24257c478bd9Sstevel@tonic-gate /* 2426e0e63816SRod Evans * If this file has been found, reset the not-found load count. 2427e0e63816SRod Evans * Although a search for this file might have inspected a number 2428e0e63816SRod Evans * of non-existent path names, the file has been found so there 242908278a5eSRod Evans * is no need to accumulate a non-found count, as this may 2430e0e63816SRod Evans * trigger unnecessary fall back (retry) processing. 2431e0e63816SRod Evans */ 2432e0e63816SRod Evans if (in_nfavl) 2433e0e63816SRod Evans *in_nfavl = oin_nfavl; 2434e0e63816SRod Evans 2435e0e63816SRod Evans /* 24367c478bd9Sstevel@tonic-gate * If we've loaded a library which identifies itself as not 24377c478bd9Sstevel@tonic-gate * being dlopen()'able catch it here. Let non-dlopen()'able 24387c478bd9Sstevel@tonic-gate * objects through under RTLD_CONFGEN as they're only being 24397c478bd9Sstevel@tonic-gate * mapped to be dldump()'ed. 24407c478bd9Sstevel@tonic-gate */ 24417c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_APPLIC) && ((FLAGS(nlmp) & 24427c478bd9Sstevel@tonic-gate (FLG_RT_NOOPEN | FLG_RT_RELOCED)) == FLG_RT_NOOPEN) && 24437c478bd9Sstevel@tonic-gate ((nmode & RTLD_CONFGEN) == 0)) { 24447c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 24457c478bd9Sstevel@tonic-gate 24467c478bd9Sstevel@tonic-gate _rej.rej_name = name; 24477c478bd9Sstevel@tonic-gate _rej.rej_type = SGS_REJ_STR; 24487c478bd9Sstevel@tonic-gate _rej.rej_str = MSG_INTL(MSG_GEN_NOOPEN); 2449ba2be530Sab196087 DBG_CALL(Dbg_file_rejected(lml, &_rej, M_MACH)); 245031fdd7caSab196087 rejection_inherit(rej, &_rej); 24512020b2b6SRod Evans remove_so(lml, nlmp, clmp); 245237ffaf83SRod Evans return (NULL); 24537c478bd9Sstevel@tonic-gate } 24547c478bd9Sstevel@tonic-gate } else { 24557c478bd9Sstevel@tonic-gate /* 24567c478bd9Sstevel@tonic-gate * If it's a NOLOAD request - check to see if the object 24577c478bd9Sstevel@tonic-gate * has already been loaded. 24587c478bd9Sstevel@tonic-gate */ 24597c478bd9Sstevel@tonic-gate /* LINTED */ 24609aa23310Srie if (nlmp = is_so_loaded(lml, name, in_nfavl)) { 24617c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_TRC_VERBOSE) && 24627c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) { 24637c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_FIL_FIND), name, 24647c478bd9Sstevel@tonic-gate NAME(clmp)); 24657247f888Srie /* BEGIN CSTYLED */ 24667c478bd9Sstevel@tonic-gate if (*name == '/') 24677c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), 24687c478bd9Sstevel@tonic-gate name, MSG_ORIG(MSG_STR_EMPTY), 24697c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 24707c478bd9Sstevel@tonic-gate else 24717c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), 24727c478bd9Sstevel@tonic-gate name, NAME(nlmp), 24737c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY), 24747c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 24757247f888Srie /* END CSTYLED */ 24767c478bd9Sstevel@tonic-gate } 24777c478bd9Sstevel@tonic-gate } else { 24787c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 24797c478bd9Sstevel@tonic-gate 24807c478bd9Sstevel@tonic-gate _rej.rej_name = name; 24817c478bd9Sstevel@tonic-gate _rej.rej_type = SGS_REJ_STR; 24827c478bd9Sstevel@tonic-gate _rej.rej_str = strerror(ENOENT); 2483ba2be530Sab196087 DBG_CALL(Dbg_file_rejected(lml, &_rej, M_MACH)); 248431fdd7caSab196087 rejection_inherit(rej, &_rej); 248537ffaf83SRod Evans return (NULL); 24867c478bd9Sstevel@tonic-gate } 24877c478bd9Sstevel@tonic-gate } 24887c478bd9Sstevel@tonic-gate 24897c478bd9Sstevel@tonic-gate /* 24907c478bd9Sstevel@tonic-gate * Finish processing this loaded object. 24917c478bd9Sstevel@tonic-gate */ 2492390b98b5Srie if (load_finish(lml, name, clmp, nmode, flags, hdl, nlmp) == 0) { 2493390b98b5Srie FLAGS(nlmp) &= ~FLG_RT_NEWLOAD; 24947c478bd9Sstevel@tonic-gate 24957c478bd9Sstevel@tonic-gate /* 2496390b98b5Srie * If this object has already been analyzed, then it is in use, 2497390b98b5Srie * so even though this operation has failed, it should not be 2498390b98b5Srie * torn down. 24997c478bd9Sstevel@tonic-gate */ 25007c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0) 25012020b2b6SRod Evans remove_so(lml, nlmp, clmp); 250237ffaf83SRod Evans return (NULL); 25037c478bd9Sstevel@tonic-gate } 25047c478bd9Sstevel@tonic-gate 25057c478bd9Sstevel@tonic-gate /* 2506390b98b5Srie * If this object is new, and we're being audited, tell the audit 25072020b2b6SRod Evans * libraries of the file we've just opened. Note, if the new link-map 2508390b98b5Srie * requires local auditing of its dependencies we also register its 2509390b98b5Srie * opening. 2510390b98b5Srie */ 2511390b98b5Srie if (FLAGS(nlmp) & FLG_RT_NEWLOAD) { 2512390b98b5Srie FLAGS(nlmp) &= ~FLG_RT_NEWLOAD; 2513390b98b5Srie 25142020b2b6SRod Evans if ((lml->lm_tflags | AFLAGS(clmp) | AFLAGS(nlmp)) & 25152020b2b6SRod Evans LML_TFLG_AUD_MASK) { 2516390b98b5Srie if (audit_objopen(clmp, nlmp) == 0) { 25172020b2b6SRod Evans remove_so(lml, nlmp, clmp); 251837ffaf83SRod Evans return (NULL); 2519390b98b5Srie } 2520390b98b5Srie } 2521390b98b5Srie } 2522390b98b5Srie return (nlmp); 2523390b98b5Srie } 2524390b98b5Srie 2525390b98b5Srie /* 25267c478bd9Sstevel@tonic-gate * Load one object from a possible list of objects. Typically, for requests 25277c478bd9Sstevel@tonic-gate * such as NEEDED's, only one object is specified. However, this object could 252808278a5eSRod Evans * be specified using $ISALIST or $CAPABILITY, in which case only the first 252908278a5eSRod Evans * object that can be loaded is used (ie. the best). 25307c478bd9Sstevel@tonic-gate */ 25317c478bd9Sstevel@tonic-gate Rt_map * 253256deab07SRod Evans load_one(Lm_list *lml, Aliste lmco, Alist *palp, Rt_map *clmp, int mode, 25339aa23310Srie uint_t flags, Grp_hdl **hdl, int *in_nfavl) 25347c478bd9Sstevel@tonic-gate { 25357c478bd9Sstevel@tonic-gate Rej_desc rej = { 0 }; 253656deab07SRod Evans Aliste idx; 253756deab07SRod Evans Pdesc *pdp; 25387c478bd9Sstevel@tonic-gate const char *name; 25397c478bd9Sstevel@tonic-gate 254056deab07SRod Evans for (ALIST_TRAVERSE(palp, idx, pdp)) { 254156deab07SRod Evans Rt_map *lmp = NULL; 25427247f888Srie 25437c478bd9Sstevel@tonic-gate /* 254408278a5eSRod Evans * A $CAPABILITY/$HWCAP requirement can expand into a number of 254508278a5eSRod Evans * candidates. 25467c478bd9Sstevel@tonic-gate */ 254708278a5eSRod Evans if (pdp->pd_flags & PD_TKN_CAP) { 254808278a5eSRod Evans lmp = load_cap(lml, lmco, pdp->pd_pname, clmp, 254908278a5eSRod Evans mode, (flags | FLG_RT_CAP), hdl, &rej, in_nfavl); 25507c478bd9Sstevel@tonic-gate } else { 255156deab07SRod Evans Fdesc fd = { 0 }; 255256deab07SRod Evans 255356deab07SRod Evans /* 255456deab07SRod Evans * Trace the inspection of this file, determine any 255556deab07SRod Evans * auditor substitution, and seed the file descriptor 255656deab07SRod Evans * with the originating name. 255756deab07SRod Evans */ 255856deab07SRod Evans if (load_trace(lml, pdp, clmp, &fd) == NULL) 255956deab07SRod Evans continue; 256056deab07SRod Evans 256156deab07SRod Evans /* 256256deab07SRod Evans * Locate and load the file. 256356deab07SRod Evans */ 256456deab07SRod Evans lmp = load_path(lml, lmco, clmp, mode, flags, hdl, &fd, 256556deab07SRod Evans &rej, in_nfavl); 25667c478bd9Sstevel@tonic-gate } 256756deab07SRod Evans if (lmp) 256856deab07SRod Evans return (lmp); 25697c478bd9Sstevel@tonic-gate } 25707c478bd9Sstevel@tonic-gate 25717c478bd9Sstevel@tonic-gate /* 257256deab07SRod Evans * If no objects can be found, use the first path name from the Alist 257356deab07SRod Evans * to provide a diagnostic. If this pathname originated from an 257456deab07SRod Evans * expanded token, use the original name for any diagnostic output. 25757c478bd9Sstevel@tonic-gate */ 257656deab07SRod Evans pdp = alist_item(palp, 0); 257756deab07SRod Evans 257856deab07SRod Evans if ((name = pdp->pd_oname) == 0) 257956deab07SRod Evans name = pdp->pd_pname; 25807c478bd9Sstevel@tonic-gate 25817c478bd9Sstevel@tonic-gate file_notfound(lml, name, clmp, flags, &rej); 258237ffaf83SRod Evans return (NULL); 25837c478bd9Sstevel@tonic-gate } 25847c478bd9Sstevel@tonic-gate 25857c478bd9Sstevel@tonic-gate /* 25869a411307Srie * Determine whether a symbol is defined as an interposer. 25879a411307Srie */ 25889a411307Srie int 25899a411307Srie is_sym_interposer(Rt_map *lmp, Sym *sym) 25909a411307Srie { 25919a411307Srie Syminfo *sip = SYMINFO(lmp); 25929a411307Srie 25939a411307Srie if (sip) { 25949a411307Srie ulong_t ndx; 25959a411307Srie 25969a411307Srie ndx = (((ulong_t)sym - (ulong_t)SYMTAB(lmp)) / SYMENT(lmp)); 25979a411307Srie /* LINTED */ 25989a411307Srie sip = (Syminfo *)((char *)sip + (ndx * SYMINENT(lmp))); 25999a411307Srie if (sip->si_flags & SYMINFO_FLG_INTERPOSE) 26009a411307Srie return (1); 26019a411307Srie } 26029a411307Srie return (0); 26039a411307Srie } 26049a411307Srie 26059a411307Srie /* 26067c478bd9Sstevel@tonic-gate * While processing direct or group bindings, determine whether the object to 26077c478bd9Sstevel@tonic-gate * which we've bound can be interposed upon. In this context, copy relocations 26087c478bd9Sstevel@tonic-gate * are a form of interposition. 26097c478bd9Sstevel@tonic-gate */ 261008278a5eSRod Evans static int 261108278a5eSRod Evans lookup_sym_interpose(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl) 26127c478bd9Sstevel@tonic-gate { 261308278a5eSRod Evans Rt_map *lmp, *clmp, *dlmp = srp->sr_dmap; 261408278a5eSRod Evans Sym *osym = srp->sr_sym; 26157c478bd9Sstevel@tonic-gate Slookup sl; 2616adbfe822Srie Lm_list *lml; 26177c478bd9Sstevel@tonic-gate 26187c478bd9Sstevel@tonic-gate /* 26197c478bd9Sstevel@tonic-gate * If we've bound to a copy relocation definition then we need to assign 26207c478bd9Sstevel@tonic-gate * this binding to the original copy reference. Fabricate an inter- 26217c478bd9Sstevel@tonic-gate * position diagnostic, as this is a legitimate form of interposition. 26227c478bd9Sstevel@tonic-gate */ 262308278a5eSRod Evans if (osym && (FLAGS1(dlmp) & FL1_RT_COPYTOOK)) { 26247c478bd9Sstevel@tonic-gate Rel_copy *rcp; 2625cce0e03bSab196087 Aliste idx; 26267c478bd9Sstevel@tonic-gate 262708278a5eSRod Evans for (ALIST_TRAVERSE(COPY_R(dlmp), idx, rcp)) { 2628aa736cbeSrie if ((osym == rcp->r_dsym) || (osym->st_value && 2629aa736cbeSrie (osym->st_value == rcp->r_dsym->st_value))) { 263008278a5eSRod Evans srp->sr_dmap = rcp->r_rlmp; 263108278a5eSRod Evans srp->sr_sym = rcp->r_rsym; 26327c478bd9Sstevel@tonic-gate *binfo |= 26337c478bd9Sstevel@tonic-gate (DBG_BINFO_INTERPOSE | DBG_BINFO_COPYREF); 263408278a5eSRod Evans return (1); 26357c478bd9Sstevel@tonic-gate } 26367c478bd9Sstevel@tonic-gate } 26377c478bd9Sstevel@tonic-gate } 26387c478bd9Sstevel@tonic-gate 2639aa736cbeSrie /* 2640adbfe822Srie * If a symbol binding has been established, inspect the link-map list 2641adbfe822Srie * of the destination object, otherwise use the link-map list of the 2642adbfe822Srie * original caller. 2643adbfe822Srie */ 2644adbfe822Srie if (osym) 264508278a5eSRod Evans clmp = dlmp; 2646adbfe822Srie else 2647adbfe822Srie clmp = slp->sl_cmap; 2648adbfe822Srie 2649adbfe822Srie lml = LIST(clmp); 2650adbfe822Srie lmp = lml->lm_head; 2651adbfe822Srie 2652adbfe822Srie /* 2653aa736cbeSrie * Prior to Solaris 8, external references from an executable that were 2654aa736cbeSrie * bound to an uninitialized variable (.bss) within a shared object did 2655aa736cbeSrie * not establish a copy relocation. This was thought to be an 2656aa736cbeSrie * optimization, to prevent copying zero's to zero's. Typically, 2657aa736cbeSrie * interposition took its course, with the shared object binding to the 2658aa736cbeSrie * executables data definition. 2659aa736cbeSrie * 2660aa736cbeSrie * This scenario can be broken when this old executable runs against a 2661aa736cbeSrie * new shared object that is directly bound. With no copy-relocation 2662aa736cbeSrie * record, ld.so.1 has no data to trigger the normal vectoring of the 2663aa736cbeSrie * binding to the executable. 2664aa736cbeSrie * 2665aa736cbeSrie * Starting with Solaris 8, a DT_FLAGS entry is written to all objects, 2666aa736cbeSrie * regardless of there being any DF_ flags entries. Therefore, an 2667aa736cbeSrie * object without this dynamic tag is susceptible to the copy relocation 2668aa736cbeSrie * issue. If the executable has no DT_FLAGS tag, and contains the same 2669aa736cbeSrie * .bss symbol definition as has been directly bound to, redirect the 2670aa736cbeSrie * binding to the executables data definition. 2671aa736cbeSrie */ 267256deab07SRod Evans if (osym && ((FLAGS1(lmp) & FL1_RT_DTFLAGS) == 0) && 2673adbfe822Srie (FCT(lmp) == &elf_fct) && 2674466e2a62Srie (ELF_ST_TYPE(osym->st_info) != STT_FUNC) && 267508278a5eSRod Evans are_bits_zero(dlmp, osym, 0)) { 267608278a5eSRod Evans Sresult sr; 2677aa736cbeSrie 267808278a5eSRod Evans /* 267908278a5eSRod Evans * Initialize a local symbol result descriptor, using the 268008278a5eSRod Evans * original symbol name. Initialize a local symbol lookup 268108278a5eSRod Evans * descriptor, using the original lookup information, and a 268208278a5eSRod Evans * new initial link-map. 268308278a5eSRod Evans */ 268408278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name); 2685adbfe822Srie sl = *slp; 2686adbfe822Srie sl.sl_imap = lmp; 2687adbfe822Srie 2688aa736cbeSrie /* 2689aa736cbeSrie * Determine whether the same symbol name exists within the 2690aa736cbeSrie * executable, that the size and type of symbol are the same, 2691aa736cbeSrie * and that the symbol is also associated with .bss. 2692aa736cbeSrie */ 269308278a5eSRod Evans if (SYMINTP(lmp)(&sl, &sr, binfo, in_nfavl)) { 269408278a5eSRod Evans Sym *isym = sr.sr_sym; 269508278a5eSRod Evans 269608278a5eSRod Evans if ((isym->st_size == osym->st_size) && 2697aa736cbeSrie (isym->st_info == osym->st_info) && 2698466e2a62Srie are_bits_zero(lmp, isym, 1)) { 269908278a5eSRod Evans *srp = sr; 270008278a5eSRod Evans *binfo |= 270108278a5eSRod Evans (DBG_BINFO_INTERPOSE | DBG_BINFO_COPYREF); 270208278a5eSRod Evans return (1); 270308278a5eSRod Evans } 2704aa736cbeSrie } 2705aa736cbeSrie } 2706aa736cbeSrie 27077c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_INTRPOSE) == 0) 270867d74cc3SToomas Soome return (0); 27097c478bd9Sstevel@tonic-gate 27107c478bd9Sstevel@tonic-gate /* 27117c478bd9Sstevel@tonic-gate * Traverse the list of known interposers to determine whether any 27127c478bd9Sstevel@tonic-gate * offer the same symbol. Note, the head of the link-map could be 2713aa736cbeSrie * identified as an interposer. Otherwise, skip the head of the 2714aa736cbeSrie * link-map, so that we don't bind to any .plt references, or 2715aa736cbeSrie * copy-relocation destinations unintentionally. 27167c478bd9Sstevel@tonic-gate */ 27177c478bd9Sstevel@tonic-gate lmp = lml->lm_head; 27187c478bd9Sstevel@tonic-gate sl = *slp; 2719adbfe822Srie 27209a411307Srie if (((FLAGS(lmp) & MSK_RT_INTPOSE) == 0) || (sl.sl_flags & LKUP_COPY)) 2721cb511613SAli Bahrami lmp = NEXT_RT_MAP(lmp); 27227c478bd9Sstevel@tonic-gate 2723cb511613SAli Bahrami for (; lmp; lmp = NEXT_RT_MAP(lmp)) { 27247c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_DELETE) 27257c478bd9Sstevel@tonic-gate continue; 27269a411307Srie if ((FLAGS(lmp) & MSK_RT_INTPOSE) == 0) 27277c478bd9Sstevel@tonic-gate break; 27287c478bd9Sstevel@tonic-gate 2729e0e63816SRod Evans /* 2730e0e63816SRod Evans * If we had already bound to this object, there's no point in 2731e0e63816SRod Evans * searching it again, we're done. 2732e0e63816SRod Evans */ 273308278a5eSRod Evans if (lmp == dlmp) 2734e0e63816SRod Evans break; 2735e0e63816SRod Evans 2736e0e63816SRod Evans /* 2737e0e63816SRod Evans * If this interposer can be inspected by the caller, look for 2738e0e63816SRod Evans * the symbol within the interposer. 2739e0e63816SRod Evans */ 2740e0e63816SRod Evans if (callable(clmp, lmp, 0, sl.sl_flags)) { 274108278a5eSRod Evans Sresult sr; 27429a411307Srie 274308278a5eSRod Evans /* 274408278a5eSRod Evans * Initialize a local symbol result descriptor, using 274508278a5eSRod Evans * the original symbol name. Initialize a local symbol 274608278a5eSRod Evans * lookup descriptor, using the original lookup 274708278a5eSRod Evans * information, and a new initial link-map. 274808278a5eSRod Evans */ 274908278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name); 27507c478bd9Sstevel@tonic-gate sl.sl_imap = lmp; 275108278a5eSRod Evans 275208278a5eSRod Evans if (SYMINTP(lmp)(&sl, &sr, binfo, in_nfavl)) { 275308278a5eSRod Evans Sym *isym = sr.sr_sym; 275408278a5eSRod Evans Rt_map *ilmp = sr.sr_dmap; 275508278a5eSRod Evans 27569a411307Srie /* 27579a411307Srie * If this object provides individual symbol 27589a411307Srie * interposers, make sure that the symbol we 27599a411307Srie * have found is tagged as an interposer. 27609a411307Srie */ 27619a411307Srie if ((FLAGS(ilmp) & FLG_RT_SYMINTPO) && 2762aa736cbeSrie (is_sym_interposer(ilmp, isym) == 0)) 27639a411307Srie continue; 27649a411307Srie 27659a411307Srie /* 27669a411307Srie * Indicate this binding has occurred to an 27679a411307Srie * interposer, and return the symbol. 27689a411307Srie */ 276908278a5eSRod Evans *srp = sr; 27707c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_INTERPOSE; 277108278a5eSRod Evans return (1); 27727c478bd9Sstevel@tonic-gate } 27737c478bd9Sstevel@tonic-gate } 27747c478bd9Sstevel@tonic-gate } 277508278a5eSRod Evans return (0); 27767c478bd9Sstevel@tonic-gate } 27777c478bd9Sstevel@tonic-gate 27787c478bd9Sstevel@tonic-gate /* 27797c478bd9Sstevel@tonic-gate * If an object specifies direct bindings (it contains a syminfo structure 27807c478bd9Sstevel@tonic-gate * describing where each binding was established during link-editing, and the 27817c478bd9Sstevel@tonic-gate * object was built -Bdirect), then look for the symbol in the specific object. 27827c478bd9Sstevel@tonic-gate */ 278308278a5eSRod Evans static int 278408278a5eSRod Evans lookup_sym_direct(Slookup *slp, Sresult *srp, uint_t *binfo, Syminfo *sip, 27859aa23310Srie Rt_map *lmp, int *in_nfavl) 27867c478bd9Sstevel@tonic-gate { 278708278a5eSRod Evans Rt_map *dlmp, *clmp = slp->sl_cmap; 278808278a5eSRod Evans int ret; 27897c478bd9Sstevel@tonic-gate Slookup sl; 27907c478bd9Sstevel@tonic-gate 27917c478bd9Sstevel@tonic-gate /* 27927c478bd9Sstevel@tonic-gate * If a direct binding resolves to the definition of a copy relocated 27937c478bd9Sstevel@tonic-gate * variable, it must be redirected to the copy (in the executable) that 27947c478bd9Sstevel@tonic-gate * will eventually be made. Typically, this redirection occurs in 27957c478bd9Sstevel@tonic-gate * lookup_sym_interpose(). But, there's an edge condition. If a 27967c478bd9Sstevel@tonic-gate * directly bound executable contains pic code, there may be a 27977c478bd9Sstevel@tonic-gate * reference to a definition that will eventually have a copy made. 27987c478bd9Sstevel@tonic-gate * However, this copy relocation may not yet have occurred, because 27997c478bd9Sstevel@tonic-gate * the relocation making this reference comes before the relocation 28007c478bd9Sstevel@tonic-gate * that will create the copy. 28017c478bd9Sstevel@tonic-gate * Under direct bindings, the syminfo indicates that a copy will be 28027c478bd9Sstevel@tonic-gate * taken (SYMINFO_FLG_COPY). This can only be set in an executable. 28037c478bd9Sstevel@tonic-gate * Thus, the caller must be the executable, so bind to the destination 28047c478bd9Sstevel@tonic-gate * of the copy within the executable. 28057c478bd9Sstevel@tonic-gate */ 28067c478bd9Sstevel@tonic-gate if (((slp->sl_flags & LKUP_COPY) == 0) && 28077c478bd9Sstevel@tonic-gate (sip->si_flags & SYMINFO_FLG_COPY)) { 28087c478bd9Sstevel@tonic-gate slp->sl_imap = LIST(clmp)->lm_head; 280908278a5eSRod Evans 281008278a5eSRod Evans if (ret = SYMINTP(clmp)(slp, srp, binfo, in_nfavl)) 28117c478bd9Sstevel@tonic-gate *binfo |= (DBG_BINFO_DIRECT | DBG_BINFO_COPYREF); 281208278a5eSRod Evans return (ret); 28137c478bd9Sstevel@tonic-gate } 28147c478bd9Sstevel@tonic-gate 28157c478bd9Sstevel@tonic-gate /* 2816efb9e8b8Srie * If we need to directly bind to our parent, start looking in each 2817efb9e8b8Srie * callers link map. 28187c478bd9Sstevel@tonic-gate */ 28197c478bd9Sstevel@tonic-gate sl = *slp; 28207c478bd9Sstevel@tonic-gate sl.sl_flags |= LKUP_DIRECT; 282108278a5eSRod Evans ret = 0; 28227c478bd9Sstevel@tonic-gate 28237c478bd9Sstevel@tonic-gate if (sip->si_boundto == SYMINFO_BT_PARENT) { 2824cce0e03bSab196087 Aliste idx1; 2825cce0e03bSab196087 Bnd_desc *bdp; 2826cce0e03bSab196087 Grp_hdl *ghp; 28277c478bd9Sstevel@tonic-gate 2828efb9e8b8Srie /* 2829efb9e8b8Srie * Determine the parent of this explicit dependency from its 2830efb9e8b8Srie * CALLERS()'s list. 2831efb9e8b8Srie */ 2832cce0e03bSab196087 for (APLIST_TRAVERSE(CALLERS(clmp), idx1, bdp)) { 2833cce0e03bSab196087 sl.sl_imap = lmp = bdp->b_caller; 283408278a5eSRod Evans if (ret = SYMINTP(lmp)(&sl, srp, binfo, in_nfavl)) 2835efb9e8b8Srie goto found; 2836efb9e8b8Srie } 2837efb9e8b8Srie 2838efb9e8b8Srie /* 2839efb9e8b8Srie * A caller can also be defined as the parent of a dlopen() 2840efb9e8b8Srie * call. Determine whether this object has any handles. The 2841efb9e8b8Srie * dependencies maintained with the handle represent the 2842efb9e8b8Srie * explicit dependencies of the dlopen()'ed object, and the 2843efb9e8b8Srie * calling parent. 2844efb9e8b8Srie */ 2845cce0e03bSab196087 for (APLIST_TRAVERSE(HANDLES(clmp), idx1, ghp)) { 2846efb9e8b8Srie Grp_desc *gdp; 2847cce0e03bSab196087 Aliste idx2; 2848efb9e8b8Srie 2849cce0e03bSab196087 for (ALIST_TRAVERSE(ghp->gh_depends, idx2, gdp)) { 2850efb9e8b8Srie if ((gdp->gd_flags & GPD_PARENT) == 0) 2851efb9e8b8Srie continue; 2852efb9e8b8Srie sl.sl_imap = lmp = gdp->gd_depend; 285308278a5eSRod Evans if (ret = SYMINTP(lmp)(&sl, srp, binfo, 285408278a5eSRod Evans in_nfavl)) 2855efb9e8b8Srie goto found; 2856efb9e8b8Srie } 28577c478bd9Sstevel@tonic-gate } 28587c478bd9Sstevel@tonic-gate } else { 28597c478bd9Sstevel@tonic-gate /* 28607c478bd9Sstevel@tonic-gate * If we need to direct bind to anything else look in the 28617c478bd9Sstevel@tonic-gate * link map associated with this symbol reference. 28627c478bd9Sstevel@tonic-gate */ 28637c478bd9Sstevel@tonic-gate if (sip->si_boundto == SYMINFO_BT_SELF) 28647c478bd9Sstevel@tonic-gate sl.sl_imap = lmp = clmp; 28657c478bd9Sstevel@tonic-gate else 28667c478bd9Sstevel@tonic-gate sl.sl_imap = lmp; 28677c478bd9Sstevel@tonic-gate 28687c478bd9Sstevel@tonic-gate if (lmp) 286908278a5eSRod Evans ret = SYMINTP(lmp)(&sl, srp, binfo, in_nfavl); 28707c478bd9Sstevel@tonic-gate } 2871efb9e8b8Srie found: 287208278a5eSRod Evans if (ret) 28737c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_DIRECT; 28747c478bd9Sstevel@tonic-gate 28757c478bd9Sstevel@tonic-gate /* 2876adbfe822Srie * If a reference to a directly bound symbol can't be satisfied, then 2877adbfe822Srie * determine whether an interposer can provide the missing symbol. If 2878adbfe822Srie * a reference to a directly bound symbol is satisfied, then determine 2879adbfe822Srie * whether that object can be interposed upon for this symbol. 28807c478bd9Sstevel@tonic-gate */ 288108278a5eSRod Evans dlmp = srp->sr_dmap; 288208278a5eSRod Evans if ((ret == 0) || (dlmp && (LIST(dlmp)->lm_head != dlmp) && 288308278a5eSRod Evans (LIST(dlmp) == LIST(clmp)))) { 288408278a5eSRod Evans if (lookup_sym_interpose(slp, srp, binfo, in_nfavl)) 288508278a5eSRod Evans return (1); 28867c478bd9Sstevel@tonic-gate } 28877c478bd9Sstevel@tonic-gate 288808278a5eSRod Evans return (ret); 28897c478bd9Sstevel@tonic-gate } 28907c478bd9Sstevel@tonic-gate 289108278a5eSRod Evans static int 289208278a5eSRod Evans core_lookup_sym(Rt_map *ilmp, Slookup *slp, Sresult *srp, uint_t *binfo, 28939aa23310Srie Aliste off, int *in_nfavl) 28947c478bd9Sstevel@tonic-gate { 28957c478bd9Sstevel@tonic-gate Rt_map *lmp; 28967c478bd9Sstevel@tonic-gate 28977c478bd9Sstevel@tonic-gate /* 28987c478bd9Sstevel@tonic-gate * Copy relocations should start their search after the head of the 28997c478bd9Sstevel@tonic-gate * main link-map control list. 29007c478bd9Sstevel@tonic-gate */ 2901cce0e03bSab196087 if ((off == ALIST_OFF_DATA) && (slp->sl_flags & LKUP_COPY) && ilmp) 2902cb511613SAli Bahrami lmp = NEXT_RT_MAP(ilmp); 29037c478bd9Sstevel@tonic-gate else 29047c478bd9Sstevel@tonic-gate lmp = ilmp; 29057c478bd9Sstevel@tonic-gate 2906cb511613SAli Bahrami for (; lmp; lmp = NEXT_RT_MAP(lmp)) { 290760758829Srie if (callable(slp->sl_cmap, lmp, 0, slp->sl_flags)) { 29087c478bd9Sstevel@tonic-gate 29097c478bd9Sstevel@tonic-gate slp->sl_imap = lmp; 291008278a5eSRod Evans if ((SYMINTP(lmp)(slp, srp, binfo, in_nfavl)) || 291137ffaf83SRod Evans (*binfo & BINFO_MSK_TRYAGAIN)) 291208278a5eSRod Evans return (1); 29137c478bd9Sstevel@tonic-gate } 29147c478bd9Sstevel@tonic-gate } 291508278a5eSRod Evans return (0); 29167c478bd9Sstevel@tonic-gate } 29177c478bd9Sstevel@tonic-gate 291808278a5eSRod Evans static int 291908278a5eSRod Evans rescan_lazy_find_sym(Rt_map *ilmp, Slookup *slp, Sresult *srp, uint_t *binfo, 29209aa23310Srie int *in_nfavl) 29217c478bd9Sstevel@tonic-gate { 29227c478bd9Sstevel@tonic-gate Rt_map *lmp; 29237c478bd9Sstevel@tonic-gate 2924cb511613SAli Bahrami for (lmp = ilmp; lmp; lmp = NEXT_RT_MAP(lmp)) { 29257c478bd9Sstevel@tonic-gate if (LAZY(lmp) == 0) 29267c478bd9Sstevel@tonic-gate continue; 292760758829Srie if (callable(slp->sl_cmap, lmp, 0, slp->sl_flags)) { 29287c478bd9Sstevel@tonic-gate 29297c478bd9Sstevel@tonic-gate slp->sl_imap = lmp; 293008278a5eSRod Evans if (elf_lazy_find_sym(slp, srp, binfo, in_nfavl)) 293108278a5eSRod Evans return (1); 29327c478bd9Sstevel@tonic-gate } 29337c478bd9Sstevel@tonic-gate } 293408278a5eSRod Evans return (0); 29357c478bd9Sstevel@tonic-gate } 29367c478bd9Sstevel@tonic-gate 293708278a5eSRod Evans static int 293808278a5eSRod Evans _lookup_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl) 29397c478bd9Sstevel@tonic-gate { 29407c478bd9Sstevel@tonic-gate const char *name = slp->sl_name; 29417c478bd9Sstevel@tonic-gate Rt_map *clmp = slp->sl_cmap; 2942dae2dfb7Srie Lm_list *lml = LIST(clmp); 29437c478bd9Sstevel@tonic-gate Rt_map *ilmp = slp->sl_imap, *lmp; 29447c478bd9Sstevel@tonic-gate ulong_t rsymndx; 294508278a5eSRod Evans int ret; 29467c478bd9Sstevel@tonic-gate Syminfo *sip; 29477c478bd9Sstevel@tonic-gate Slookup sl; 29487c478bd9Sstevel@tonic-gate 29497c478bd9Sstevel@tonic-gate /* 29507c478bd9Sstevel@tonic-gate * Search the initial link map for the required symbol (this category is 29517c478bd9Sstevel@tonic-gate * selected by dlsym(), where individual link maps are searched for a 29527c478bd9Sstevel@tonic-gate * required symbol. Therefore, we know we have permission to look at 29537c478bd9Sstevel@tonic-gate * the link map). 29547c478bd9Sstevel@tonic-gate */ 295560758829Srie if (slp->sl_flags & LKUP_FIRST) 295608278a5eSRod Evans return (SYMINTP(ilmp)(slp, srp, binfo, in_nfavl)); 29577c478bd9Sstevel@tonic-gate 29587c478bd9Sstevel@tonic-gate /* 29597c478bd9Sstevel@tonic-gate * Determine whether this lookup can be satisfied by an objects direct, 29607c478bd9Sstevel@tonic-gate * or lazy binding information. This is triggered by a relocation from 29617c478bd9Sstevel@tonic-gate * the object (hence rsymndx is set). 29627c478bd9Sstevel@tonic-gate */ 29637c478bd9Sstevel@tonic-gate if (((rsymndx = slp->sl_rsymndx) != 0) && 2964aa736cbeSrie ((sip = SYMINFO(clmp)) != NULL)) { 2965dae2dfb7Srie uint_t bound; 2966dae2dfb7Srie 29677c478bd9Sstevel@tonic-gate /* 29687c478bd9Sstevel@tonic-gate * Find the corresponding Syminfo entry for the original 29697c478bd9Sstevel@tonic-gate * referencing symbol. 29707c478bd9Sstevel@tonic-gate */ 29717c478bd9Sstevel@tonic-gate /* LINTED */ 29727c478bd9Sstevel@tonic-gate sip = (Syminfo *)((char *)sip + (rsymndx * SYMINENT(clmp))); 2973dae2dfb7Srie bound = sip->si_boundto; 2974dae2dfb7Srie 2975dae2dfb7Srie /* 2976dae2dfb7Srie * Identify any EXTERN or PARENT references for ldd(1). 2977dae2dfb7Srie */ 2978dae2dfb7Srie if ((lml->lm_flags & LML_FLG_TRC_WARN) && 2979dae2dfb7Srie (bound > SYMINFO_BT_LOWRESERVE)) { 2980dae2dfb7Srie if (bound == SYMINFO_BT_PARENT) 2981dae2dfb7Srie *binfo |= DBG_BINFO_REF_PARENT; 2982dae2dfb7Srie if (bound == SYMINFO_BT_EXTERN) 2983dae2dfb7Srie *binfo |= DBG_BINFO_REF_EXTERN; 2984dae2dfb7Srie } 29857c478bd9Sstevel@tonic-gate 29867c478bd9Sstevel@tonic-gate /* 29877c478bd9Sstevel@tonic-gate * If the symbol information indicates a direct binding, 29887c478bd9Sstevel@tonic-gate * determine the link map that is required to satisfy the 29897c478bd9Sstevel@tonic-gate * binding. Note, if the dependency can not be found, but a 29907c478bd9Sstevel@tonic-gate * direct binding isn't required, we will still fall through 29917c478bd9Sstevel@tonic-gate * to perform any default symbol search. 29927c478bd9Sstevel@tonic-gate */ 29937c478bd9Sstevel@tonic-gate if (sip->si_flags & SYMINFO_FLG_DIRECT) { 29947c478bd9Sstevel@tonic-gate 29957c478bd9Sstevel@tonic-gate lmp = 0; 29967c478bd9Sstevel@tonic-gate if (bound < SYMINFO_BT_LOWRESERVE) 29979aa23310Srie lmp = elf_lazy_load(clmp, slp, bound, 29982017c965SRod Evans name, 0, NULL, in_nfavl); 29997c478bd9Sstevel@tonic-gate 30007c478bd9Sstevel@tonic-gate /* 30017c478bd9Sstevel@tonic-gate * If direct bindings have been disabled, and this isn't 30027c478bd9Sstevel@tonic-gate * a translator, skip any direct binding now that we've 300360758829Srie * ensured the resolving object has been loaded. 30047c478bd9Sstevel@tonic-gate * 30057c478bd9Sstevel@tonic-gate * If we need to direct bind to anything, we look in 30067c478bd9Sstevel@tonic-gate * ourselves, our parent, or in the link map we've just 30077c478bd9Sstevel@tonic-gate * loaded. Otherwise, even though we may have lazily 30087c478bd9Sstevel@tonic-gate * loaded an object we still continue to search for 30097c478bd9Sstevel@tonic-gate * symbols from the head of the link map list. 30107c478bd9Sstevel@tonic-gate */ 30117c478bd9Sstevel@tonic-gate if (((FLAGS(clmp) & FLG_RT_TRANS) || 3012dae2dfb7Srie (((lml->lm_tflags & LML_TFLG_NODIRECT) == 0) && 3013dae2dfb7Srie ((slp->sl_flags & LKUP_SINGLETON) == 0))) && 30149a411307Srie ((FLAGS1(clmp) & FL1_RT_DIRECT) || 30157c478bd9Sstevel@tonic-gate (sip->si_flags & SYMINFO_FLG_DIRECTBIND))) { 301608278a5eSRod Evans ret = lookup_sym_direct(slp, srp, binfo, 30179aa23310Srie sip, lmp, in_nfavl); 30187c478bd9Sstevel@tonic-gate 30197c478bd9Sstevel@tonic-gate /* 302060758829Srie * Determine whether this direct binding has 302160758829Srie * been rejected. If we've bound to a singleton 302260758829Srie * without following a singleton search, then 302360758829Srie * return. The caller detects this condition 302460758829Srie * and will trigger a new singleton search. 302560758829Srie * 302660758829Srie * For any other rejection (such as binding to 302760758829Srie * a symbol labeled as nodirect - presumably 302860758829Srie * because the symbol definition has been 302960758829Srie * changed since the referring object was last 303060758829Srie * built), fall through to a standard symbol 30317c478bd9Sstevel@tonic-gate * search. 30327c478bd9Sstevel@tonic-gate */ 303337ffaf83SRod Evans if (((*binfo & BINFO_MSK_REJECTED) == 0) || 303437ffaf83SRod Evans (*binfo & BINFO_MSK_TRYAGAIN)) 303508278a5eSRod Evans return (ret); 303660758829Srie 303737ffaf83SRod Evans *binfo &= ~BINFO_MSK_REJECTED; 30387c478bd9Sstevel@tonic-gate } 30397c478bd9Sstevel@tonic-gate } 30407c478bd9Sstevel@tonic-gate } 30417c478bd9Sstevel@tonic-gate 304260758829Srie /* 304360758829Srie * Duplicate the lookup information, as we'll need to modify this 304460758829Srie * information for some of the following searches. 304560758829Srie */ 30467c478bd9Sstevel@tonic-gate sl = *slp; 30477c478bd9Sstevel@tonic-gate 30487c478bd9Sstevel@tonic-gate /* 30497c478bd9Sstevel@tonic-gate * If the referencing object has the DF_SYMBOLIC flag set, look in the 30507c478bd9Sstevel@tonic-gate * referencing object for the symbol first. Failing that, fall back to 30517c478bd9Sstevel@tonic-gate * our generic search. 30527c478bd9Sstevel@tonic-gate */ 305360758829Srie if ((FLAGS1(clmp) & FL1_RT_SYMBOLIC) && 305460758829Srie ((sl.sl_flags & LKUP_SINGLETON) == 0)) { 305508278a5eSRod Evans 30567c478bd9Sstevel@tonic-gate sl.sl_imap = clmp; 305708278a5eSRod Evans if (SYMINTP(clmp)(&sl, srp, binfo, in_nfavl)) { 305808278a5eSRod Evans Rt_map *dlmp = srp->sr_dmap; 305908278a5eSRod Evans ulong_t dsymndx = (((ulong_t)srp->sr_sym - 306008278a5eSRod Evans (ulong_t)SYMTAB(dlmp)) / SYMENT(dlmp)); 30619a411307Srie 30629a411307Srie /* 30639a411307Srie * Make sure this symbol hasn't explicitly been defined 30649a411307Srie * as nodirect. 30659a411307Srie */ 306608278a5eSRod Evans if (((sip = SYMINFO(dlmp)) == 0) || 30679a411307Srie /* LINTED */ 30689a411307Srie ((sip = (Syminfo *)((char *)sip + 306908278a5eSRod Evans (dsymndx * SYMINENT(dlmp)))) == 0) || 30709a411307Srie ((sip->si_flags & SYMINFO_FLG_NOEXTDIRECT) == 0)) 307108278a5eSRod Evans return (1); 30727c478bd9Sstevel@tonic-gate } 30739a411307Srie } 30747c478bd9Sstevel@tonic-gate 307560758829Srie sl.sl_flags |= LKUP_STANDARD; 307660758829Srie 30777c478bd9Sstevel@tonic-gate /* 30787c478bd9Sstevel@tonic-gate * If this lookup originates from a standard relocation, then traverse 307960758829Srie * all link-map control lists, inspecting any object that is available 308060758829Srie * to this caller. Otherwise, traverse the link-map control list 308160758829Srie * associated with the caller. 30827c478bd9Sstevel@tonic-gate */ 308360758829Srie if (sl.sl_flags & LKUP_STDRELOC) { 30847c478bd9Sstevel@tonic-gate Aliste off; 30857c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 30867c478bd9Sstevel@tonic-gate 308708278a5eSRod Evans ret = 0; 30887c478bd9Sstevel@tonic-gate 3089dae2dfb7Srie for (ALIST_TRAVERSE_BY_OFFSET(lml->lm_lists, off, lmc)) { 309008278a5eSRod Evans if (((ret = core_lookup_sym(lmc->lc_head, &sl, srp, 309108278a5eSRod Evans binfo, off, in_nfavl)) != 0) || 309237ffaf83SRod Evans (*binfo & BINFO_MSK_TRYAGAIN)) 30937c478bd9Sstevel@tonic-gate break; 30947c478bd9Sstevel@tonic-gate } 30957c478bd9Sstevel@tonic-gate } else 309608278a5eSRod Evans ret = core_lookup_sym(ilmp, &sl, srp, binfo, ALIST_OFF_DATA, 30979aa23310Srie in_nfavl); 309860758829Srie 309960758829Srie /* 310037ffaf83SRod Evans * If a symbol binding should be retried, return so that the search can 310137ffaf83SRod Evans * be repeated. 310260758829Srie */ 310337ffaf83SRod Evans if (*binfo & BINFO_MSK_TRYAGAIN) 310408278a5eSRod Evans return (0); 31057c478bd9Sstevel@tonic-gate 31067c478bd9Sstevel@tonic-gate /* 31077c478bd9Sstevel@tonic-gate * To allow transitioning into a world of lazy loading dependencies see 31087c478bd9Sstevel@tonic-gate * if this link map contains objects that have lazy dependencies still 31097c478bd9Sstevel@tonic-gate * outstanding. If so, and we haven't been able to locate a non-weak 31107c478bd9Sstevel@tonic-gate * symbol reference, start bringing in any lazy dependencies to see if 31117c478bd9Sstevel@tonic-gate * the reference can be satisfied. Use of dlsym(RTLD_PROBE) sets the 311275e7992aSrie * LKUP_NOFALLBACK flag, and this flag disables this fall back. 31137c478bd9Sstevel@tonic-gate */ 311408278a5eSRod Evans if ((ret == 0) && ((sl.sl_flags & LKUP_NOFALLBACK) == 0)) { 31157c478bd9Sstevel@tonic-gate if ((lmp = ilmp) == 0) 31167c478bd9Sstevel@tonic-gate lmp = LIST(clmp)->lm_head; 311775e7992aSrie 3118dae2dfb7Srie lml = LIST(lmp); 3119dae2dfb7Srie if ((sl.sl_flags & LKUP_WEAK) || (lml->lm_lazy == 0)) 312067d74cc3SToomas Soome return (0); 31217c478bd9Sstevel@tonic-gate 3122dae2dfb7Srie DBG_CALL(Dbg_syms_lazy_rescan(lml, name)); 31237c478bd9Sstevel@tonic-gate 31247c478bd9Sstevel@tonic-gate /* 31257c478bd9Sstevel@tonic-gate * If this request originated from a dlsym(RTLD_NEXT) then start 31267c478bd9Sstevel@tonic-gate * looking for dependencies from the caller, otherwise use the 31277c478bd9Sstevel@tonic-gate * initial link-map. 31287c478bd9Sstevel@tonic-gate */ 312960758829Srie if (sl.sl_flags & LKUP_NEXT) 313008278a5eSRod Evans ret = rescan_lazy_find_sym(clmp, &sl, srp, binfo, 31312017c965SRod Evans in_nfavl); 31327c478bd9Sstevel@tonic-gate else { 3133cce0e03bSab196087 Aliste idx; 31347c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 31357c478bd9Sstevel@tonic-gate 3136dae2dfb7Srie for (ALIST_TRAVERSE(lml->lm_lists, idx, lmc)) { 313775e7992aSrie sl.sl_flags |= LKUP_NOFALLBACK; 313808278a5eSRod Evans if (ret = rescan_lazy_find_sym(lmc->lc_head, 313908278a5eSRod Evans &sl, srp, binfo, in_nfavl)) 31407c478bd9Sstevel@tonic-gate break; 31417c478bd9Sstevel@tonic-gate } 31427c478bd9Sstevel@tonic-gate } 31437c478bd9Sstevel@tonic-gate } 314408278a5eSRod Evans return (ret); 314560758829Srie } 314660758829Srie 314760758829Srie /* 314860758829Srie * Symbol lookup routine. Takes an ELF symbol name, and a list of link maps to 314960758829Srie * search. If successful, return a pointer to the symbol table entry, a 315060758829Srie * pointer to the link map of the enclosing object, and information relating 315160758829Srie * to the type of binding. Else return a null pointer. 315260758829Srie */ 315308278a5eSRod Evans int 315408278a5eSRod Evans lookup_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl) 315560758829Srie { 315660758829Srie Rt_map *clmp = slp->sl_cmap; 315708278a5eSRod Evans Sym *rsym = slp->sl_rsym; 315808278a5eSRod Evans uchar_t rtype = slp->sl_rtype, vis; 315908278a5eSRod Evans int ret, mode; 316060758829Srie 316160758829Srie if (slp->sl_hash == 0) 316275e7992aSrie slp->sl_hash = elf_hash(slp->sl_name); 316360758829Srie *binfo = 0; 316460758829Srie 316560758829Srie if (rsym) { 316608278a5eSRod Evans vis = ELF_ST_VISIBILITY(rsym->st_other); 316708278a5eSRod Evans 316808278a5eSRod Evans /* 316908278a5eSRod Evans * Symbols that are defined as protected, or hidden, within an 317008278a5eSRod Evans * object usually have any relocation references from within 317108278a5eSRod Evans * the same object bound at link-edit time. Therefore, ld.so.1 317208278a5eSRod Evans * is not involved. However, if a reference is to a 317308278a5eSRod Evans * capabilities symbol, this reference must be resolved at 317408278a5eSRod Evans * runtime. In this case look directly within the calling 317508278a5eSRod Evans * object, and only within the calling object, for these 317608278a5eSRod Evans * symbols. Note, an object may still use dlsym() to search 317708278a5eSRod Evans * externally for a symbol which is defined as protected within 317808278a5eSRod Evans * the same object. 317908278a5eSRod Evans */ 318008278a5eSRod Evans if ((rsym->st_shndx != SHN_UNDEF) && 318108278a5eSRod Evans ((slp->sl_flags & LKUP_DLSYM) == 0) && 318208278a5eSRod Evans ((vis == STV_PROTECTED) || (vis == STV_HIDDEN))) { 318308278a5eSRod Evans slp->sl_imap = clmp; 318408278a5eSRod Evans return (SYMINTP(clmp)(slp, srp, binfo, in_nfavl)); 318508278a5eSRod Evans } 318608278a5eSRod Evans 318708278a5eSRod Evans /* 318808278a5eSRod Evans * Establish any state that might be associated with a symbol 318908278a5eSRod Evans * reference. 319008278a5eSRod Evans */ 319160758829Srie if ((slp->sl_flags & LKUP_STDRELOC) && 319260758829Srie (ELF_ST_BIND(rsym->st_info) == STB_WEAK)) 319360758829Srie slp->sl_flags |= LKUP_WEAK; 319460758829Srie 319508278a5eSRod Evans if (vis == STV_SINGLETON) 319660758829Srie slp->sl_flags |= LKUP_SINGLETON; 319760758829Srie } 319860758829Srie 319960758829Srie /* 320060758829Srie * Establish any lookup state required for this type of relocation. 320160758829Srie */ 320260758829Srie if ((slp->sl_flags & LKUP_STDRELOC) && rtype) { 320360758829Srie if (rtype == M_R_COPY) 320460758829Srie slp->sl_flags |= LKUP_COPY; 320560758829Srie 320660758829Srie if (rtype != M_R_JMP_SLOT) 320760758829Srie slp->sl_flags |= LKUP_SPEC; 320860758829Srie } 320960758829Srie 321060758829Srie /* 321160758829Srie * Under ldd -w, any unresolved weak references are diagnosed. Set the 321260758829Srie * symbol binding as global to trigger a relocation error if the symbol 321360758829Srie * can not be found. 321460758829Srie */ 321560758829Srie if (rsym) { 321660758829Srie if (LIST(slp->sl_cmap)->lm_flags & LML_FLG_TRC_NOUNRESWEAK) 321760758829Srie slp->sl_bind = STB_GLOBAL; 321860758829Srie else if ((slp->sl_bind = ELF_ST_BIND(rsym->st_info)) == 321960758829Srie STB_WEAK) 322060758829Srie slp->sl_flags |= LKUP_WEAK; 322160758829Srie } 322260758829Srie 322360758829Srie /* 322437ffaf83SRod Evans * Save the callers MODE(). 322537ffaf83SRod Evans */ 322637ffaf83SRod Evans mode = MODE(clmp); 322737ffaf83SRod Evans 322837ffaf83SRod Evans /* 322960758829Srie * Carry out an initial symbol search. This search takes into account 323060758829Srie * all the modes of the requested search. 323160758829Srie */ 323208278a5eSRod Evans if (((ret = _lookup_sym(slp, srp, binfo, in_nfavl)) == 0) && 323337ffaf83SRod Evans (*binfo & BINFO_MSK_TRYAGAIN)) { 323460758829Srie Slookup sl = *slp; 323560758829Srie 323660758829Srie /* 323737ffaf83SRod Evans * Try the symbol search again. This retry can be necessary if: 323837ffaf83SRod Evans * 32392017c965SRod Evans * - a binding has been rejected because of binding to a 324037ffaf83SRod Evans * singleton without going through a singleton search. 32412017c965SRod Evans * - a group binding has resulted in binding to a symbol 324237ffaf83SRod Evans * that indicates no-direct binding. 324337ffaf83SRod Evans * 324437ffaf83SRod Evans * Reset the lookup data, and try again. 324560758829Srie */ 324660758829Srie sl.sl_imap = LIST(sl.sl_cmap)->lm_head; 324760758829Srie sl.sl_flags &= ~(LKUP_FIRST | LKUP_SELF | LKUP_NEXT); 324860758829Srie sl.sl_rsymndx = 0; 324937ffaf83SRod Evans 325037ffaf83SRod Evans if (*binfo & BINFO_REJSINGLE) 325137ffaf83SRod Evans sl.sl_flags |= LKUP_SINGLETON; 325237ffaf83SRod Evans if (*binfo & BINFO_REJGROUP) { 325337ffaf83SRod Evans sl.sl_flags |= LKUP_WORLD; 325437ffaf83SRod Evans mode |= RTLD_WORLD; 325537ffaf83SRod Evans } 325637ffaf83SRod Evans *binfo &= ~BINFO_MSK_REJECTED; 325737ffaf83SRod Evans 325808278a5eSRod Evans ret = _lookup_sym(&sl, srp, binfo, in_nfavl); 325960758829Srie } 32607c478bd9Sstevel@tonic-gate 32617c478bd9Sstevel@tonic-gate /* 32627c478bd9Sstevel@tonic-gate * If the caller is restricted to a symbol search within its group, 32637c478bd9Sstevel@tonic-gate * determine if it is necessary to follow a binding from outside of 32647c478bd9Sstevel@tonic-gate * the group. 32657c478bd9Sstevel@tonic-gate */ 326608278a5eSRod Evans if (((mode & (RTLD_GROUP | RTLD_WORLD)) == RTLD_GROUP) && 326708278a5eSRod Evans (lookup_sym_interpose(slp, srp, binfo, in_nfavl))) 326808278a5eSRod Evans return (1); 32697c478bd9Sstevel@tonic-gate 327008278a5eSRod Evans return (ret); 32717c478bd9Sstevel@tonic-gate } 32727c478bd9Sstevel@tonic-gate 32737c478bd9Sstevel@tonic-gate /* 32747c478bd9Sstevel@tonic-gate * Associate a binding descriptor with a caller and its dependency, or update 32757c478bd9Sstevel@tonic-gate * an existing descriptor. 32767c478bd9Sstevel@tonic-gate */ 32777c478bd9Sstevel@tonic-gate int 32787c478bd9Sstevel@tonic-gate bind_one(Rt_map *clmp, Rt_map *dlmp, uint_t flags) 32797c478bd9Sstevel@tonic-gate { 3280cce0e03bSab196087 Bnd_desc *bdp; 3281cce0e03bSab196087 Aliste idx; 32827c478bd9Sstevel@tonic-gate int found = ALE_CREATE; 32837c478bd9Sstevel@tonic-gate 32847c478bd9Sstevel@tonic-gate /* 32857c478bd9Sstevel@tonic-gate * Determine whether a binding descriptor already exists between the 32867c478bd9Sstevel@tonic-gate * two objects. 32877c478bd9Sstevel@tonic-gate */ 3288cce0e03bSab196087 for (APLIST_TRAVERSE(DEPENDS(clmp), idx, bdp)) { 32897c478bd9Sstevel@tonic-gate if (bdp->b_depend == dlmp) { 32907c478bd9Sstevel@tonic-gate found = ALE_EXISTS; 32917c478bd9Sstevel@tonic-gate break; 32927c478bd9Sstevel@tonic-gate } 32937c478bd9Sstevel@tonic-gate } 32947c478bd9Sstevel@tonic-gate 32957c478bd9Sstevel@tonic-gate if (found == ALE_CREATE) { 32967c478bd9Sstevel@tonic-gate /* 32977c478bd9Sstevel@tonic-gate * Create a new binding descriptor. 32987c478bd9Sstevel@tonic-gate */ 329937ffaf83SRod Evans if ((bdp = malloc(sizeof (Bnd_desc))) == NULL) 33007c478bd9Sstevel@tonic-gate return (0); 33017c478bd9Sstevel@tonic-gate 33027c478bd9Sstevel@tonic-gate bdp->b_caller = clmp; 33037c478bd9Sstevel@tonic-gate bdp->b_depend = dlmp; 33047c478bd9Sstevel@tonic-gate bdp->b_flags = 0; 33057c478bd9Sstevel@tonic-gate 33067c478bd9Sstevel@tonic-gate /* 33077c478bd9Sstevel@tonic-gate * Append the binding descriptor to the caller and the 33087c478bd9Sstevel@tonic-gate * dependency. 33097c478bd9Sstevel@tonic-gate */ 331056deab07SRod Evans if (aplist_append(&DEPENDS(clmp), bdp, AL_CNT_DEPENDS) == NULL) 33117c478bd9Sstevel@tonic-gate return (0); 33127c478bd9Sstevel@tonic-gate 331356deab07SRod Evans if (aplist_append(&CALLERS(dlmp), bdp, AL_CNT_CALLERS) == NULL) 33147c478bd9Sstevel@tonic-gate return (0); 33157c478bd9Sstevel@tonic-gate } 33167c478bd9Sstevel@tonic-gate 33177c478bd9Sstevel@tonic-gate if ((found == ALE_CREATE) || ((bdp->b_flags & flags) != flags)) { 33187c478bd9Sstevel@tonic-gate bdp->b_flags |= flags; 33197c478bd9Sstevel@tonic-gate 33207c478bd9Sstevel@tonic-gate if (flags & BND_REFER) 33217c478bd9Sstevel@tonic-gate FLAGS1(dlmp) |= FL1_RT_USED; 33227c478bd9Sstevel@tonic-gate 33235aefb655Srie DBG_CALL(Dbg_file_bind_entry(LIST(clmp), bdp)); 33247c478bd9Sstevel@tonic-gate } 33257c478bd9Sstevel@tonic-gate return (found); 33267c478bd9Sstevel@tonic-gate } 33277c478bd9Sstevel@tonic-gate 33287c478bd9Sstevel@tonic-gate /* 33297c478bd9Sstevel@tonic-gate * Cleanup after relocation processing. 33307c478bd9Sstevel@tonic-gate */ 33317c478bd9Sstevel@tonic-gate int 333256deab07SRod Evans relocate_finish(Rt_map *lmp, APlist *bound, int ret) 33337c478bd9Sstevel@tonic-gate { 33345aefb655Srie DBG_CALL(Dbg_reloc_run(lmp, 0, ret, DBG_REL_FINISH)); 33357c478bd9Sstevel@tonic-gate 33367c478bd9Sstevel@tonic-gate /* 33377c478bd9Sstevel@tonic-gate * Establish bindings to all objects that have been bound to. 33387c478bd9Sstevel@tonic-gate */ 33397c478bd9Sstevel@tonic-gate if (bound) { 3340cce0e03bSab196087 Rt_map *_lmp; 33418a20d9f8Srie Word used; 33427c478bd9Sstevel@tonic-gate 33438a20d9f8Srie /* 33448a20d9f8Srie * Only create bindings if the callers relocation was 33458a20d9f8Srie * successful (ret != 0), otherwise the object will eventually 33468a20d9f8Srie * be torn down. Create these bindings if running under ldd(1) 33478a20d9f8Srie * with the -U/-u options regardless of relocation errors, as 33488a20d9f8Srie * the unused processing needs to traverse these bindings to 33498a20d9f8Srie * diagnose unused objects. 33508a20d9f8Srie */ 33518a20d9f8Srie used = LIST(lmp)->lm_flags & 33528a20d9f8Srie (LML_FLG_TRC_UNREF | LML_FLG_TRC_UNUSED); 33538a20d9f8Srie 33548a20d9f8Srie if (ret || used) { 335556deab07SRod Evans Aliste idx; 335656deab07SRod Evans 3357cce0e03bSab196087 for (APLIST_TRAVERSE(bound, idx, _lmp)) { 33588a20d9f8Srie if (bind_one(lmp, _lmp, BND_REFER) || used) 33598a20d9f8Srie continue; 33608a20d9f8Srie 33617c478bd9Sstevel@tonic-gate ret = 0; 33627c478bd9Sstevel@tonic-gate break; 33637c478bd9Sstevel@tonic-gate } 33647c478bd9Sstevel@tonic-gate } 33657c478bd9Sstevel@tonic-gate free(bound); 33667c478bd9Sstevel@tonic-gate } 33677c478bd9Sstevel@tonic-gate 33687c478bd9Sstevel@tonic-gate return (ret); 33697c478bd9Sstevel@tonic-gate } 337056deab07SRod Evans 337156deab07SRod Evans /* 337256deab07SRod Evans * Function to correct protection settings. Segments are all mapped initially 337356deab07SRod Evans * with permissions as given in the segment header. We need to turn on write 337456deab07SRod Evans * permissions on a text segment if there are any relocations against that 337556deab07SRod Evans * segment, and then turn write permission back off again before returning 337656deab07SRod Evans * control to the caller. This function turns the permission on or off 337756deab07SRod Evans * depending on the value of the permission argument. 337856deab07SRod Evans */ 337956deab07SRod Evans int 338056deab07SRod Evans set_prot(Rt_map *lmp, mmapobj_result_t *mpp, int perm) 338156deab07SRod Evans { 338256deab07SRod Evans int prot; 338356deab07SRod Evans 338456deab07SRod Evans /* 338556deab07SRod Evans * If this is an allocated image (ie. a relocatable object) we can't 338656deab07SRod Evans * mprotect() anything. 338756deab07SRod Evans */ 338856deab07SRod Evans if (FLAGS(lmp) & FLG_RT_IMGALLOC) 338956deab07SRod Evans return (1); 339056deab07SRod Evans 339156deab07SRod Evans DBG_CALL(Dbg_file_prot(lmp, perm)); 339256deab07SRod Evans 339356deab07SRod Evans if (perm) 339456deab07SRod Evans prot = mpp->mr_prot | PROT_WRITE; 339556deab07SRod Evans else 339656deab07SRod Evans prot = mpp->mr_prot & ~PROT_WRITE; 339756deab07SRod Evans 339856deab07SRod Evans if (mprotect((void *)(uintptr_t)mpp->mr_addr, 339956deab07SRod Evans mpp->mr_msize, prot) == -1) { 340056deab07SRod Evans int err = errno; 340156deab07SRod Evans eprintf(LIST(lmp), ERR_FATAL, MSG_INTL(MSG_SYS_MPROT), 340256deab07SRod Evans NAME(lmp), strerror(err)); 340356deab07SRod Evans return (0); 340456deab07SRod Evans } 340556deab07SRod Evans mpp->mr_prot = prot; 340656deab07SRod Evans return (1); 340756deab07SRod Evans } 3408