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 5*5aefb655Srie * Common Development and Distribution License (the "License"). 6*5aefb655Srie * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21fb1354edSrie 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright (c) 1988 AT&T 247c478bd9Sstevel@tonic-gate * All Rights Reserved 257c478bd9Sstevel@tonic-gate * 26*5aefb655Srie * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 277c478bd9Sstevel@tonic-gate * Use is subject to license terms. 287c478bd9Sstevel@tonic-gate */ 297c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate #include "_synonyms.h" 327c478bd9Sstevel@tonic-gate 337c478bd9Sstevel@tonic-gate #include <string.h> 347c478bd9Sstevel@tonic-gate #include <stdio.h> 357c478bd9Sstevel@tonic-gate #include <unistd.h> 367c478bd9Sstevel@tonic-gate #include <sys/stat.h> 377c478bd9Sstevel@tonic-gate #include <sys/mman.h> 387c478bd9Sstevel@tonic-gate #include <fcntl.h> 397c478bd9Sstevel@tonic-gate #include <limits.h> 407c478bd9Sstevel@tonic-gate #include <dlfcn.h> 417c478bd9Sstevel@tonic-gate #include <errno.h> 427c478bd9Sstevel@tonic-gate #include <link.h> 43*5aefb655Srie #include <debug.h> 44*5aefb655Srie #include <conv.h> 457c478bd9Sstevel@tonic-gate #include "_rtld.h" 467c478bd9Sstevel@tonic-gate #include "_audit.h" 477c478bd9Sstevel@tonic-gate #include "_elf.h" 487c478bd9Sstevel@tonic-gate #include "msg.h" 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate static Fct * vector[] = { 517c478bd9Sstevel@tonic-gate &elf_fct, 527c478bd9Sstevel@tonic-gate #ifdef A_OUT 537c478bd9Sstevel@tonic-gate &aout_fct, 547c478bd9Sstevel@tonic-gate #endif 557c478bd9Sstevel@tonic-gate 0 567c478bd9Sstevel@tonic-gate }; 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate /* 597c478bd9Sstevel@tonic-gate * If a load filter flag is in effect, and this object is a filter, trigger the 607c478bd9Sstevel@tonic-gate * loading of all its filtees. The load filter flag is in effect when creating 617c478bd9Sstevel@tonic-gate * configuration files, or when under the control of ldd(1), or the LD_LOADFLTR 627c478bd9Sstevel@tonic-gate * environment variable is set, or this object was built with the -zloadfltr 637c478bd9Sstevel@tonic-gate * flag. Otherwise, filtee loading is deferred until triggered by a relocation. 647c478bd9Sstevel@tonic-gate */ 657c478bd9Sstevel@tonic-gate static void 667c478bd9Sstevel@tonic-gate load_filtees(Rt_map *lmp) 677c478bd9Sstevel@tonic-gate { 687c478bd9Sstevel@tonic-gate if ((FLAGS1(lmp) & MSK_RT_FILTER) && 697c478bd9Sstevel@tonic-gate ((FLAGS(lmp) & FLG_RT_LOADFLTR) || 707c478bd9Sstevel@tonic-gate (LIST(lmp)->lm_tflags & LML_TFLG_LOADFLTR))) { 717c478bd9Sstevel@tonic-gate Dyninfo * dip = DYNINFO(lmp); 727c478bd9Sstevel@tonic-gate uint_t cnt, max = DYNINFOCNT(lmp); 737c478bd9Sstevel@tonic-gate Slookup sl; 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate sl.sl_name = 0; 767c478bd9Sstevel@tonic-gate sl.sl_hash = 0; 777c478bd9Sstevel@tonic-gate sl.sl_imap = sl.sl_cmap = lmp; 787c478bd9Sstevel@tonic-gate 797c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < max; cnt++, dip++) { 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; 847c478bd9Sstevel@tonic-gate (void) elf_lookup_filtee(&sl, 0, 0, cnt); 857c478bd9Sstevel@tonic-gate } 867c478bd9Sstevel@tonic-gate } 877c478bd9Sstevel@tonic-gate } 887c478bd9Sstevel@tonic-gate 897c478bd9Sstevel@tonic-gate /* 907c478bd9Sstevel@tonic-gate * Analyze one or more link-maps of a link map control list. This routine is 917c478bd9Sstevel@tonic-gate * called at startup to continue the processing of the main executable. It is 927c478bd9Sstevel@tonic-gate * also called each time a new set of objects are loaded, ie. from filters, 937c478bd9Sstevel@tonic-gate * lazy-loaded objects, or dlopen(). 947c478bd9Sstevel@tonic-gate * 957c478bd9Sstevel@tonic-gate * In each instance we traverse the link-map control list starting with the 967c478bd9Sstevel@tonic-gate * initial object. As dependencies are analyzed they are added to the link-map 977c478bd9Sstevel@tonic-gate * control list. Thus the list grows as we traverse it - this results in the 987c478bd9Sstevel@tonic-gate * breadth first ordering of all needed objects. 997c478bd9Sstevel@tonic-gate */ 1007c478bd9Sstevel@tonic-gate int 1017c478bd9Sstevel@tonic-gate analyze_lmc(Lm_list *lml, Aliste nlmco, Rt_map *nlmp) 1027c478bd9Sstevel@tonic-gate { 1037c478bd9Sstevel@tonic-gate Rt_map *lmp = nlmp; 1047c478bd9Sstevel@tonic-gate Lm_cntl *nlmc; 1057c478bd9Sstevel@tonic-gate int ret = 1; 1067c478bd9Sstevel@tonic-gate 1077c478bd9Sstevel@tonic-gate /* 1087c478bd9Sstevel@tonic-gate * If this link-map control list is being analyzed, return. The object 1097c478bd9Sstevel@tonic-gate * that has just been added will be picked up by the existing analysis 1107c478bd9Sstevel@tonic-gate * thread. Note, this is only really meaningful during process init- 1117c478bd9Sstevel@tonic-gate * ialization, as objects are added to the main link-map control list. 1127c478bd9Sstevel@tonic-gate * Following this initialization, each family of objects that are loaded 1137c478bd9Sstevel@tonic-gate * are added to a new link-map control list. 1147c478bd9Sstevel@tonic-gate */ 1157c478bd9Sstevel@tonic-gate /* LINTED */ 1167c478bd9Sstevel@tonic-gate nlmc = (Lm_cntl *)((char *)lml->lm_lists + nlmco); 1177c478bd9Sstevel@tonic-gate if (nlmc->lc_flags & LMC_FLG_ANALYZING) 1187c478bd9Sstevel@tonic-gate return (1); 1197c478bd9Sstevel@tonic-gate 1207c478bd9Sstevel@tonic-gate /* 1217c478bd9Sstevel@tonic-gate * If this object doesn't belong to the present link-map control list 1227c478bd9Sstevel@tonic-gate * then it must already have been analyzed, or it is in the process of 1237c478bd9Sstevel@tonic-gate * being analyzed prior to us recursing into this analysis. In either 1247c478bd9Sstevel@tonic-gate * case, ignore the object as it's already being taken care of. 1257c478bd9Sstevel@tonic-gate */ 1267c478bd9Sstevel@tonic-gate if (nlmco != CNTL(nlmp)) 1277c478bd9Sstevel@tonic-gate return (1); 1287c478bd9Sstevel@tonic-gate 1297c478bd9Sstevel@tonic-gate nlmc->lc_flags |= LMC_FLG_ANALYZING; 1307c478bd9Sstevel@tonic-gate 1317c478bd9Sstevel@tonic-gate for (; lmp; lmp = (Rt_map *)NEXT(lmp)) { 1327c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & 1337c478bd9Sstevel@tonic-gate (FLG_RT_ANALZING | FLG_RT_ANALYZED | FLG_RT_DELETE)) 1347c478bd9Sstevel@tonic-gate continue; 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate /* 1377c478bd9Sstevel@tonic-gate * Indicate that analyzing is under way. 1387c478bd9Sstevel@tonic-gate */ 1397c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_ANALZING; 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate /* 1427c478bd9Sstevel@tonic-gate * If this link map represents a relocatable object, then we 1437c478bd9Sstevel@tonic-gate * need to finish the link-editing of the object at this point. 1447c478bd9Sstevel@tonic-gate */ 1457c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_OBJECT) { 1467c478bd9Sstevel@tonic-gate if (elf_obj_fini(lml, lmp) == 0) { 1477c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) 1487c478bd9Sstevel@tonic-gate continue; 1497c478bd9Sstevel@tonic-gate ret = 0; 1507c478bd9Sstevel@tonic-gate break; 1517c478bd9Sstevel@tonic-gate } 1527c478bd9Sstevel@tonic-gate } 1537c478bd9Sstevel@tonic-gate 1547c478bd9Sstevel@tonic-gate DBG_CALL(Dbg_file_analyze(lmp)); 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate /* 1577c478bd9Sstevel@tonic-gate * Establish any dependencies this object requires. 1587c478bd9Sstevel@tonic-gate */ 1597c478bd9Sstevel@tonic-gate if (LM_NEEDED(lmp)(lml, nlmco, lmp) == 0) { 1607c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) 1617c478bd9Sstevel@tonic-gate continue; 1627c478bd9Sstevel@tonic-gate ret = 0; 1637c478bd9Sstevel@tonic-gate break; 1647c478bd9Sstevel@tonic-gate } 1657c478bd9Sstevel@tonic-gate 1667c478bd9Sstevel@tonic-gate FLAGS(lmp) &= ~FLG_RT_ANALZING; 1677c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_ANALYZED; 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate /* 1707c478bd9Sstevel@tonic-gate * If we're building a configuration file, determine if this 1717c478bd9Sstevel@tonic-gate * object is a filter and if so load its filtees. This 1727c478bd9Sstevel@tonic-gate * traversal is only necessary for crle(1), as typical use of 1737c478bd9Sstevel@tonic-gate * an object will load filters as part of relocation processing. 1747c478bd9Sstevel@tonic-gate */ 1757c478bd9Sstevel@tonic-gate if (MODE(nlmp) & RTLD_CONFGEN) 1767c478bd9Sstevel@tonic-gate load_filtees(lmp); 1777c478bd9Sstevel@tonic-gate 1787c478bd9Sstevel@tonic-gate /* 1797c478bd9Sstevel@tonic-gate * If an interposer has been added, it will have been inserted 1807c478bd9Sstevel@tonic-gate * in the link-map before the link we're presently analyzing. 1817c478bd9Sstevel@tonic-gate * Break out of this analysis loop and return to the head of 1827c478bd9Sstevel@tonic-gate * the link-map control list to analyze the interposer. Note 1837c478bd9Sstevel@tonic-gate * that this rescan preserves the breadth first loading of 1847c478bd9Sstevel@tonic-gate * dependencies. 1857c478bd9Sstevel@tonic-gate */ 18624a6229eSrie /* LINTED */ 18724a6229eSrie nlmc = (Lm_cntl *)((char *)lml->lm_lists + nlmco); 1887c478bd9Sstevel@tonic-gate if (nlmc->lc_flags & LMC_FLG_REANALYZE) { 1897c478bd9Sstevel@tonic-gate nlmc->lc_flags &= ~LMC_FLG_REANALYZE; 1907c478bd9Sstevel@tonic-gate lmp = nlmc->lc_head; 1917c478bd9Sstevel@tonic-gate } 1927c478bd9Sstevel@tonic-gate } 1937c478bd9Sstevel@tonic-gate 19424a6229eSrie /* LINTED */ 19524a6229eSrie nlmc = (Lm_cntl *)((char *)lml->lm_lists + nlmco); 1967c478bd9Sstevel@tonic-gate nlmc->lc_flags &= ~LMC_FLG_ANALYZING; 1977c478bd9Sstevel@tonic-gate 1987c478bd9Sstevel@tonic-gate return (ret); 1997c478bd9Sstevel@tonic-gate } 2007c478bd9Sstevel@tonic-gate 2017c478bd9Sstevel@tonic-gate /* 2027c478bd9Sstevel@tonic-gate * Copy relocation test. If the symbol definition is within .bss, then it's 2037c478bd9Sstevel@tonic-gate * zero filled, and as the destination is within .bss, we can skip copying 2047c478bd9Sstevel@tonic-gate * zero's to zero's. However, if the destination object has a MOVE table, it's 2057c478bd9Sstevel@tonic-gate * .bss might contain non-zero data, in which case copy it regardless. 2067c478bd9Sstevel@tonic-gate */ 2077c478bd9Sstevel@tonic-gate static int 2087c478bd9Sstevel@tonic-gate copy_zerobits(Rt_map *dlmp, Sym *dsym) 2097c478bd9Sstevel@tonic-gate { 2107c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & FLG_RT_MOVE) == 0) { 2117c478bd9Sstevel@tonic-gate Mmap *mmaps; 2127c478bd9Sstevel@tonic-gate caddr_t daddr = (caddr_t)dsym->st_value; 2137c478bd9Sstevel@tonic-gate 2147c478bd9Sstevel@tonic-gate if ((FLAGS(dlmp) & FLG_RT_FIXED) == 0) 2157c478bd9Sstevel@tonic-gate daddr += ADDR(dlmp); 2167c478bd9Sstevel@tonic-gate 2177c478bd9Sstevel@tonic-gate for (mmaps = MMAPS(dlmp); mmaps->m_vaddr; mmaps++) { 2187c478bd9Sstevel@tonic-gate if ((mmaps->m_fsize != mmaps->m_msize) && 2197c478bd9Sstevel@tonic-gate (daddr >= (mmaps->m_vaddr + mmaps->m_fsize)) && 2207c478bd9Sstevel@tonic-gate (daddr < (mmaps->m_vaddr + mmaps->m_msize))) 2217c478bd9Sstevel@tonic-gate return (1); 2227c478bd9Sstevel@tonic-gate } 2237c478bd9Sstevel@tonic-gate } 2247c478bd9Sstevel@tonic-gate return (0); 2257c478bd9Sstevel@tonic-gate } 2267c478bd9Sstevel@tonic-gate 2277c478bd9Sstevel@tonic-gate /* 2287c478bd9Sstevel@tonic-gate * Relocate an individual object. 2297c478bd9Sstevel@tonic-gate */ 2307c478bd9Sstevel@tonic-gate static int 2317c478bd9Sstevel@tonic-gate relocate_so(Lm_list *lml, Rt_map *lmp, int *relocated, int now) 2327c478bd9Sstevel@tonic-gate { 2337c478bd9Sstevel@tonic-gate /* 2347c478bd9Sstevel@tonic-gate * If we're running under ldd(1), and haven't been asked to trace any 2357c478bd9Sstevel@tonic-gate * warnings, skip any actual relocation processing. 2367c478bd9Sstevel@tonic-gate */ 2377c478bd9Sstevel@tonic-gate if (((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0) || 2387c478bd9Sstevel@tonic-gate (lml->lm_flags & LML_FLG_TRC_WARN)) { 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate if (relocated) 2417c478bd9Sstevel@tonic-gate (*relocated)++; 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate if ((LM_RELOC(lmp)(lmp, now) == 0) && 2447c478bd9Sstevel@tonic-gate ((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0)) 2457c478bd9Sstevel@tonic-gate return (0); 2467c478bd9Sstevel@tonic-gate } 2477c478bd9Sstevel@tonic-gate return (1); 2487c478bd9Sstevel@tonic-gate } 2497c478bd9Sstevel@tonic-gate 2507c478bd9Sstevel@tonic-gate /* 2517c478bd9Sstevel@tonic-gate * Relocate the objects on a link-map control list. 2527c478bd9Sstevel@tonic-gate */ 2537c478bd9Sstevel@tonic-gate static int 2547c478bd9Sstevel@tonic-gate _relocate_lmc(Lm_list *lml, Rt_map *nlmp, int *relocated) 2557c478bd9Sstevel@tonic-gate { 2567c478bd9Sstevel@tonic-gate Rt_map *lmp; 2577c478bd9Sstevel@tonic-gate 2587c478bd9Sstevel@tonic-gate for (lmp = nlmp; lmp; lmp = (Rt_map *)NEXT(lmp)) { 2597c478bd9Sstevel@tonic-gate /* 2607c478bd9Sstevel@tonic-gate * If this object has already been relocated, we're done. If 2617c478bd9Sstevel@tonic-gate * this object is being deleted, skip it, there's probably a 2627c478bd9Sstevel@tonic-gate * relocation error somewhere that's causing this deletion. 2637c478bd9Sstevel@tonic-gate */ 2647c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & 2657c478bd9Sstevel@tonic-gate (FLG_RT_RELOCING | FLG_RT_RELOCED | FLG_RT_DELETE)) 2667c478bd9Sstevel@tonic-gate continue; 2677c478bd9Sstevel@tonic-gate 2687c478bd9Sstevel@tonic-gate /* 2697c478bd9Sstevel@tonic-gate * Indicate that relocation processing is under way. 2707c478bd9Sstevel@tonic-gate */ 2717c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_RELOCING; 2727c478bd9Sstevel@tonic-gate 2737c478bd9Sstevel@tonic-gate /* 2747c478bd9Sstevel@tonic-gate * Relocate the object. 2757c478bd9Sstevel@tonic-gate */ 2767c478bd9Sstevel@tonic-gate if (relocate_so(lml, lmp, relocated, 0) == 0) 2777c478bd9Sstevel@tonic-gate return (0); 2787c478bd9Sstevel@tonic-gate 2797c478bd9Sstevel@tonic-gate /* 2807c478bd9Sstevel@tonic-gate * Indicate that the objects relocation is complete. 2817c478bd9Sstevel@tonic-gate */ 2827c478bd9Sstevel@tonic-gate FLAGS(lmp) &= ~FLG_RT_RELOCING; 2837c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_RELOCED; 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate /* 2867c478bd9Sstevel@tonic-gate * Mark this object's init is available for harvesting. Under 2877c478bd9Sstevel@tonic-gate * ldd(1) this marking is necessary for -i (tsort) gathering. 2887c478bd9Sstevel@tonic-gate */ 2897c478bd9Sstevel@tonic-gate lml->lm_init++; 290dffec89cSrie lml->lm_flags |= LML_FLG_OBJADDED; 2917c478bd9Sstevel@tonic-gate 2927c478bd9Sstevel@tonic-gate /* 2937c478bd9Sstevel@tonic-gate * None of the following processing is necessary under ldd(). 2947c478bd9Sstevel@tonic-gate */ 2957c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0) { 2967c478bd9Sstevel@tonic-gate /* 2977c478bd9Sstevel@tonic-gate * Process any move data. 2987c478bd9Sstevel@tonic-gate */ 2997c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_MOVE) 3007c478bd9Sstevel@tonic-gate move_data(lmp); 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate /* 3037c478bd9Sstevel@tonic-gate * Process any DT_SUNW_RTLDINFO information now the 3047c478bd9Sstevel@tonic-gate * object is relocated, and remove the RTLDINFO 3057c478bd9Sstevel@tonic-gate * infrastructure as it won't be needed anymore. 3067c478bd9Sstevel@tonic-gate * 3077c478bd9Sstevel@tonic-gate * We wait until lmp == lm_info_lmp, as it's at this 3087c478bd9Sstevel@tonic-gate * stage we know the object contributing RTLDINFO has 3097c478bd9Sstevel@tonic-gate * been properly relocated. 3107c478bd9Sstevel@tonic-gate */ 3117c478bd9Sstevel@tonic-gate if ((FCT(lmp) == &elf_fct) && (lml->lm_rtldinfo) && 3127c478bd9Sstevel@tonic-gate (lmp == lml->lm_info_lmp)) { 3137c478bd9Sstevel@tonic-gate Aliste off; 3147c478bd9Sstevel@tonic-gate Lc_interface ** funcs; 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(lml->lm_rtldinfo, 3177c478bd9Sstevel@tonic-gate off, funcs)) 3187c478bd9Sstevel@tonic-gate get_lcinterface(lmp, *funcs); 3197c478bd9Sstevel@tonic-gate free(lml->lm_rtldinfo); 3207c478bd9Sstevel@tonic-gate lml->lm_rtldinfo = 0; 3217c478bd9Sstevel@tonic-gate } 3227c478bd9Sstevel@tonic-gate } 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate /* 3257c478bd9Sstevel@tonic-gate * Determine if this object is a filter, and if a load filter 3267c478bd9Sstevel@tonic-gate * flag is in effect, trigger the loading of all its filtees. 3277c478bd9Sstevel@tonic-gate */ 3287c478bd9Sstevel@tonic-gate load_filtees(lmp); 3297c478bd9Sstevel@tonic-gate } 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate /* 3327c478bd9Sstevel@tonic-gate * Perform special copy relocations. These are only meaningful for 3337c478bd9Sstevel@tonic-gate * dynamic executables (fixed and head of their link-map list). If 3347c478bd9Sstevel@tonic-gate * this ever has to change then the infrastructure of COPY() has to 3357c478bd9Sstevel@tonic-gate * change as presently this element is used to capture both receiver 3367c478bd9Sstevel@tonic-gate * and supplier of copy data. 3377c478bd9Sstevel@tonic-gate */ 3387c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) & FLG_RT_FIXED) && (nlmp == LIST(nlmp)->lm_head) && 3397c478bd9Sstevel@tonic-gate (((lml->lm_flags & LML_FLG_TRC_ENABLE) == 0) || 3407c478bd9Sstevel@tonic-gate (lml->lm_flags & LML_FLG_TRC_WARN))) { 3417c478bd9Sstevel@tonic-gate Rt_map ** lmpp; 3427c478bd9Sstevel@tonic-gate Aliste off1; 3437c478bd9Sstevel@tonic-gate Word tracing; 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate #if defined(__sparc) || defined(__amd64) 3467c478bd9Sstevel@tonic-gate /* XX64 don't need this once the compilers are fixed */ 3477c478bd9Sstevel@tonic-gate #elif defined(i386) 3487c478bd9Sstevel@tonic-gate if (elf_copy_gen(nlmp) == 0) 3497c478bd9Sstevel@tonic-gate return (0); 3507c478bd9Sstevel@tonic-gate #endif 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate if (COPY(nlmp) == 0) 3537c478bd9Sstevel@tonic-gate return (1); 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate if ((LIST(nlmp)->lm_flags & LML_FLG_TRC_ENABLE) && 3567c478bd9Sstevel@tonic-gate (((rtld_flags & RT_FL_SILENCERR) == 0) || 3577c478bd9Sstevel@tonic-gate (LIST(nlmp)->lm_flags & LML_FLG_TRC_VERBOSE))) 3587c478bd9Sstevel@tonic-gate tracing = 1; 3597c478bd9Sstevel@tonic-gate else 3607c478bd9Sstevel@tonic-gate tracing = 0; 3617c478bd9Sstevel@tonic-gate 362*5aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 3637c478bd9Sstevel@tonic-gate 3647c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(COPY(nlmp), off1, lmpp)) { 3657c478bd9Sstevel@tonic-gate Rt_map * lmp = *lmpp; 3667c478bd9Sstevel@tonic-gate Rel_copy * rcp; 3677c478bd9Sstevel@tonic-gate Aliste off2; 3687c478bd9Sstevel@tonic-gate 3697c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(COPY(lmp), off2, rcp)) { 3707c478bd9Sstevel@tonic-gate int zero; 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate /* 3737c478bd9Sstevel@tonic-gate * Only copy the bits if it's from non-zero 3747c478bd9Sstevel@tonic-gate * filled memory. 3757c478bd9Sstevel@tonic-gate */ 3767c478bd9Sstevel@tonic-gate zero = copy_zerobits(rcp->r_dlmp, rcp->r_dsym); 377*5aefb655Srie DBG_CALL(Dbg_reloc_copy(rcp->r_dlmp, nlmp, 378*5aefb655Srie rcp->r_name, zero)); 3797c478bd9Sstevel@tonic-gate if (zero) 3807c478bd9Sstevel@tonic-gate continue; 3817c478bd9Sstevel@tonic-gate 3827c478bd9Sstevel@tonic-gate (void) memcpy(rcp->r_radd, rcp->r_dadd, 3837c478bd9Sstevel@tonic-gate rcp->r_size); 3847c478bd9Sstevel@tonic-gate 3857c478bd9Sstevel@tonic-gate if ((tracing == 0) || ((FLAGS1(rcp->r_dlmp) & 3867c478bd9Sstevel@tonic-gate FL1_RT_DISPREL) == 0)) 3877c478bd9Sstevel@tonic-gate continue; 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_REL_CPYDISP), 3907c478bd9Sstevel@tonic-gate demangle(rcp->r_name), NAME(rcp->r_dlmp)); 3917c478bd9Sstevel@tonic-gate } 3927c478bd9Sstevel@tonic-gate } 3937c478bd9Sstevel@tonic-gate 394*5aefb655Srie DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 3957c478bd9Sstevel@tonic-gate 3967c478bd9Sstevel@tonic-gate free(COPY(nlmp)); 3977c478bd9Sstevel@tonic-gate COPY(nlmp) = 0; 3987c478bd9Sstevel@tonic-gate } 3997c478bd9Sstevel@tonic-gate return (1); 4007c478bd9Sstevel@tonic-gate } 4017c478bd9Sstevel@tonic-gate 4027c478bd9Sstevel@tonic-gate int 4037c478bd9Sstevel@tonic-gate relocate_lmc(Lm_list *lml, Aliste nlmco, Rt_map *nlmp) 4047c478bd9Sstevel@tonic-gate { 4057c478bd9Sstevel@tonic-gate int lret = 1, pret = 1; 4067c478bd9Sstevel@tonic-gate Alist *alp; 4077c478bd9Sstevel@tonic-gate Aliste plmco; 4087c478bd9Sstevel@tonic-gate Lm_cntl *plmc, *nlmc; 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate /* 4117c478bd9Sstevel@tonic-gate * If this link-map control list is being relocated, return. The object 4127c478bd9Sstevel@tonic-gate * that has just been added will be picked up by the existing relocation 4137c478bd9Sstevel@tonic-gate * thread. Note, this is only really meaningful during process init- 4147c478bd9Sstevel@tonic-gate * ialization, as objects are added to the main link-map control list. 4157c478bd9Sstevel@tonic-gate * Following this initialization, each family of objects that are loaded 4167c478bd9Sstevel@tonic-gate * are added to a new link-map control list. 4177c478bd9Sstevel@tonic-gate */ 4187c478bd9Sstevel@tonic-gate /* LINTED */ 4197c478bd9Sstevel@tonic-gate nlmc = (Lm_cntl *)((char *)lml->lm_lists + nlmco); 4207c478bd9Sstevel@tonic-gate 4217c478bd9Sstevel@tonic-gate if (nlmc->lc_flags & LMC_FLG_RELOCATING) 4227c478bd9Sstevel@tonic-gate return (1); 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate nlmc->lc_flags |= LMC_FLG_RELOCATING; 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate /* 4277c478bd9Sstevel@tonic-gate * Relocate one or more link-maps of a link map control list. If this 4287c478bd9Sstevel@tonic-gate * object doesn't belong to the present link-map control list then it 4297c478bd9Sstevel@tonic-gate * must already have been relocated, or it is in the process of being 4307c478bd9Sstevel@tonic-gate * relocated prior to us recursing into this relocation. In either 4317c478bd9Sstevel@tonic-gate * case, ignore the object as it's already being taken care of, however, 4327c478bd9Sstevel@tonic-gate * fall through and capture any relocation promotions that might have 4337c478bd9Sstevel@tonic-gate * been established from the reference mode of this object. 4347c478bd9Sstevel@tonic-gate * 4357c478bd9Sstevel@tonic-gate * If we're generating a configuration file using crle(1), two passes 4367c478bd9Sstevel@tonic-gate * may be involved. Under the first pass, RTLD_CONFGEN is set. Under 4377c478bd9Sstevel@tonic-gate * this pass, crle() loads objects into the process address space. No 4387c478bd9Sstevel@tonic-gate * relocation is necessary at this point, we simply need to analyze the 4397c478bd9Sstevel@tonic-gate * objects to insure any directly bound dependencies, filtees, etc. 4407c478bd9Sstevel@tonic-gate * get loaded. Although we skip the relocation, fall through to insure 4417c478bd9Sstevel@tonic-gate * any control lists are maintained appropriately. 4427c478bd9Sstevel@tonic-gate * 4437c478bd9Sstevel@tonic-gate * If objects are to be dldump(3c)'ed, crle(1) makes a second pass, 4447c478bd9Sstevel@tonic-gate * using RTLD_NOW and RTLD_CONFGEN. The RTLD_NOW effectively carries 4457c478bd9Sstevel@tonic-gate * out the relocations of all loaded objects. 4467c478bd9Sstevel@tonic-gate */ 4477c478bd9Sstevel@tonic-gate if ((nlmco == CNTL(nlmp)) && 4487c478bd9Sstevel@tonic-gate ((MODE(nlmp) & (RTLD_NOW | RTLD_CONFGEN)) != RTLD_CONFGEN)) { 4497c478bd9Sstevel@tonic-gate int relocated = 0; 4507c478bd9Sstevel@tonic-gate 4517c478bd9Sstevel@tonic-gate /* 4527c478bd9Sstevel@tonic-gate * Determine whether the initial link-map control list has 4537c478bd9Sstevel@tonic-gate * started relocation. From this point, should any interposing 4547c478bd9Sstevel@tonic-gate * objects be added to this link-map control list, the objects 4557c478bd9Sstevel@tonic-gate * are demoted to standard objects. Their interposition can't 4567c478bd9Sstevel@tonic-gate * be guaranteed once relocations have been carried out. 4577c478bd9Sstevel@tonic-gate */ 4587c478bd9Sstevel@tonic-gate if (nlmco == ALO_DATA) 4597c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_STARTREL; 4607c478bd9Sstevel@tonic-gate 4617c478bd9Sstevel@tonic-gate /* 4627c478bd9Sstevel@tonic-gate * Relocate the link-map control list. 4637c478bd9Sstevel@tonic-gate */ 4647c478bd9Sstevel@tonic-gate lret = _relocate_lmc(lml, nlmp, &relocated); 4657c478bd9Sstevel@tonic-gate 4667c478bd9Sstevel@tonic-gate /* 4677c478bd9Sstevel@tonic-gate * At this point we've completed the addition of a new group of 4687c478bd9Sstevel@tonic-gate * objects, either the initial objects that start the process 4697c478bd9Sstevel@tonic-gate * (called from setup()), a group added through lazy loading or 4707c478bd9Sstevel@tonic-gate * filters, or from a dlopen() request. Indicate to the 4717c478bd9Sstevel@tonic-gate * debuggers that new objects have been added. 4727c478bd9Sstevel@tonic-gate */ 4737c478bd9Sstevel@tonic-gate if (relocated && lret && 4747c478bd9Sstevel@tonic-gate ((lml->lm_flags & LML_FLG_DBNOTIF) == 0)) 4757c478bd9Sstevel@tonic-gate rd_event(lml, RD_DLACTIVITY, RT_ADD); 4767c478bd9Sstevel@tonic-gate } 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate /* 4797c478bd9Sstevel@tonic-gate * Determine the new, and previous link-map control lists. 4807c478bd9Sstevel@tonic-gate */ 48124a6229eSrie /* LINTED */ 48224a6229eSrie nlmc = (Lm_cntl *)((char *)lml->lm_lists + nlmco); 4836679fdc0Srie if (nlmco == ALO_DATA) { 4846679fdc0Srie plmco = nlmco; 4857c478bd9Sstevel@tonic-gate plmc = nlmc; 4866679fdc0Srie } else { 4877c478bd9Sstevel@tonic-gate plmco = nlmco - lml->lm_lists->al_size; 4887c478bd9Sstevel@tonic-gate /* LINTED */ 4897c478bd9Sstevel@tonic-gate plmc = (Lm_cntl *)((char *)lml->lm_lists + plmco); 4907c478bd9Sstevel@tonic-gate } 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate /* 4937c478bd9Sstevel@tonic-gate * Having completed this control list of objects, they can now be bound 4947c478bd9Sstevel@tonic-gate * to from other objects. Move this control list to the control list 4957c478bd9Sstevel@tonic-gate * that precedes it. Although this control list may have only bound to 4967c478bd9Sstevel@tonic-gate * controls lists much higher up the control list stack, it must only 4977c478bd9Sstevel@tonic-gate * be moved up one control list so as to preserve the link-map order 4987c478bd9Sstevel@tonic-gate * that may have already been traversed in search of symbols. 4997c478bd9Sstevel@tonic-gate */ 5007c478bd9Sstevel@tonic-gate if (lret && (nlmco != ALO_DATA) && nlmc->lc_head) 5017c478bd9Sstevel@tonic-gate lm_move(lml, nlmco, plmco, nlmc, plmc); 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate /* 5047c478bd9Sstevel@tonic-gate * Determine whether existing objects that have already been relocated, 5057c478bd9Sstevel@tonic-gate * need any additional relocations performed. This can occur when new 5067c478bd9Sstevel@tonic-gate * objects are loaded with RTLD_NOW, and these new objects have 5077c478bd9Sstevel@tonic-gate * dependencies on objects that are already loaded. Note, that we peel 5087c478bd9Sstevel@tonic-gate * any relocation promotions off of one control list at a time. This 5097c478bd9Sstevel@tonic-gate * prevents relocations from being bound to objects that might yet fail 5107c478bd9Sstevel@tonic-gate * to relocate themselves. 5117c478bd9Sstevel@tonic-gate */ 5127c478bd9Sstevel@tonic-gate while ((alp = plmc->lc_now) != 0) { 5137c478bd9Sstevel@tonic-gate Aliste off; 5147c478bd9Sstevel@tonic-gate Rt_map **lmpp; 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate /* 5177c478bd9Sstevel@tonic-gate * Remove the relocation promotion list, as performing more 5187c478bd9Sstevel@tonic-gate * relocations may result in discovering more objects that need 5197c478bd9Sstevel@tonic-gate * promotion. 5207c478bd9Sstevel@tonic-gate */ 5217c478bd9Sstevel@tonic-gate plmc->lc_now = 0; 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(alp, off, lmpp)) { 5247c478bd9Sstevel@tonic-gate Rt_map *lmp = *lmpp; 5257c478bd9Sstevel@tonic-gate 5267c478bd9Sstevel@tonic-gate /* 5277c478bd9Sstevel@tonic-gate * If the original relocation of the link-map control 5287c478bd9Sstevel@tonic-gate * list failed, or one of the relocation promotions of 5297c478bd9Sstevel@tonic-gate * this loop has failed, demote any pending objects 5307c478bd9Sstevel@tonic-gate * relocation mode. 5317c478bd9Sstevel@tonic-gate */ 5327c478bd9Sstevel@tonic-gate if ((lret == 0) || (pret == 0)) { 5337c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_NOW; 5347c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_LAZY; 5357c478bd9Sstevel@tonic-gate continue; 5367c478bd9Sstevel@tonic-gate } 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate /* 5397c478bd9Sstevel@tonic-gate * If a relocation fails, save the error condition. 5407c478bd9Sstevel@tonic-gate * It's possible that all new objects on the original 5417c478bd9Sstevel@tonic-gate * link-map control list have been relocated 5427c478bd9Sstevel@tonic-gate * successfully, but if the user request requires 5437c478bd9Sstevel@tonic-gate * promoting objects that have already been loaded, we 5447c478bd9Sstevel@tonic-gate * have to indicate that this operation couldn't be 5457c478bd9Sstevel@tonic-gate * performed. The unrelocated objects are in use on 5467c478bd9Sstevel@tonic-gate * another control list, and may continue to be used. 5477c478bd9Sstevel@tonic-gate * If the .plt that resulted in the error is called, 5487c478bd9Sstevel@tonic-gate * then the process will receive a fatal error at that 5497c478bd9Sstevel@tonic-gate * time. But, the .plt may never be called. 5507c478bd9Sstevel@tonic-gate */ 5517c478bd9Sstevel@tonic-gate if (relocate_so(lml, lmp, 0, 1) == 0) 5527c478bd9Sstevel@tonic-gate pret = 0; 5537c478bd9Sstevel@tonic-gate } 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate /* 5567c478bd9Sstevel@tonic-gate * Having promoted any objects, determine whether additional 5577c478bd9Sstevel@tonic-gate * dependencies were added, and if so move them to the previous 5587c478bd9Sstevel@tonic-gate * link-map control list. 5597c478bd9Sstevel@tonic-gate */ 56024a6229eSrie /* LINTED */ 56124a6229eSrie nlmc = (Lm_cntl *)((char *)lml->lm_lists + nlmco); 56224a6229eSrie /* LINTED */ 56324a6229eSrie plmc = (Lm_cntl *)((char *)lml->lm_lists + plmco); 5647c478bd9Sstevel@tonic-gate if ((nlmco != ALO_DATA) && nlmc->lc_head) 5657c478bd9Sstevel@tonic-gate lm_move(lml, nlmco, plmco, nlmc, plmc); 5667c478bd9Sstevel@tonic-gate (void) free(alp); 5677c478bd9Sstevel@tonic-gate } 5687c478bd9Sstevel@tonic-gate 56924a6229eSrie /* 57024a6229eSrie * Indicate that relocations are no longer active for this control list. 57124a6229eSrie */ 57224a6229eSrie /* LINTED */ 57324a6229eSrie nlmc = (Lm_cntl *)((char *)lml->lm_lists + nlmco); 5747c478bd9Sstevel@tonic-gate nlmc->lc_flags &= ~LMC_FLG_RELOCATING; 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate if (lret && pret) 5777c478bd9Sstevel@tonic-gate return (1); 5787c478bd9Sstevel@tonic-gate else 5797c478bd9Sstevel@tonic-gate return (0); 5807c478bd9Sstevel@tonic-gate } 5817c478bd9Sstevel@tonic-gate 5827c478bd9Sstevel@tonic-gate /* 5837c478bd9Sstevel@tonic-gate * Inherit the first rejection message for possible later diagnostics. 5847c478bd9Sstevel@tonic-gate * 5857c478bd9Sstevel@tonic-gate * Any attempt to process a file that is unsuccessful, should be accompanied 5867c478bd9Sstevel@tonic-gate * with an error diagnostic. However, some operations like searching for a 5877c478bd9Sstevel@tonic-gate * simple filename, involve trying numerous paths, and an error message for each 5887c478bd9Sstevel@tonic-gate * lookup is not required. Although a multiple search can fail, it's possible 5897c478bd9Sstevel@tonic-gate * that a file was found, but was rejected because it was the wrong type. 5907c478bd9Sstevel@tonic-gate * To satisfy these possibilities, the first failure is recorded as a rejection 5917c478bd9Sstevel@tonic-gate * message, and this message is used later for a more specific diagnostic. 5927c478bd9Sstevel@tonic-gate * 5937c478bd9Sstevel@tonic-gate * File searches are focused at load_one(), and from here a rejection descriptor 5947c478bd9Sstevel@tonic-gate * is passed down to various child routines. If these child routines can 5957c478bd9Sstevel@tonic-gate * process multiple files, then they will maintain their own rejection desc- 5967c478bd9Sstevel@tonic-gate * riptor. This is filled in for any failures, and a diagnostic produced to 5977c478bd9Sstevel@tonic-gate * reflect the failure. The child routines then employ rejection_inherit() to 5987c478bd9Sstevel@tonic-gate * pass the first rejection message back to load_one(). 5997c478bd9Sstevel@tonic-gate * 6007c478bd9Sstevel@tonic-gate * Note that the name, and rejection string must be duplicated, as the name 6017c478bd9Sstevel@tonic-gate * buffer and error string buffer (see conv_ routines) may be reused for 6027c478bd9Sstevel@tonic-gate * additional processing or rejection messages. 6037c478bd9Sstevel@tonic-gate * 6047c478bd9Sstevel@tonic-gate * As this routine is called to clean up after a failed open, remove any 6057c478bd9Sstevel@tonic-gate * resolved pathname that might have been allocated as the file was processed. 6067c478bd9Sstevel@tonic-gate */ 6077c478bd9Sstevel@tonic-gate void 6087c478bd9Sstevel@tonic-gate rejection_inherit(Rej_desc *rej1, Rej_desc *rej2, Fdesc *fdp) 6097c478bd9Sstevel@tonic-gate { 6107c478bd9Sstevel@tonic-gate if (rej2->rej_type && (rej1->rej_type == 0)) { 6117c478bd9Sstevel@tonic-gate rej1->rej_type = rej2->rej_type; 6127c478bd9Sstevel@tonic-gate rej1->rej_info = rej2->rej_info; 6137c478bd9Sstevel@tonic-gate rej1->rej_flag = rej2->rej_flag; 6147c478bd9Sstevel@tonic-gate if (rej2->rej_name) 6157c478bd9Sstevel@tonic-gate rej1->rej_name = strdup(rej2->rej_name); 6167c478bd9Sstevel@tonic-gate if (rej2->rej_str) { 6177c478bd9Sstevel@tonic-gate if ((rej1->rej_str = strdup(rej2->rej_str)) == 0) 6187c478bd9Sstevel@tonic-gate rej1->rej_str = MSG_ORIG(MSG_EMG_ENOMEM); 6197c478bd9Sstevel@tonic-gate } 6207c478bd9Sstevel@tonic-gate } 6217c478bd9Sstevel@tonic-gate if (fdp && fdp->fd_nname && fdp->fd_pname && 6227c478bd9Sstevel@tonic-gate (fdp->fd_pname != fdp->fd_nname)) { 6237c478bd9Sstevel@tonic-gate free((void *)fdp->fd_pname); 6247c478bd9Sstevel@tonic-gate fdp->fd_pname = 0; 6257c478bd9Sstevel@tonic-gate } 6267c478bd9Sstevel@tonic-gate } 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate /* 6297c478bd9Sstevel@tonic-gate * Determine the object type of a file. 6307c478bd9Sstevel@tonic-gate */ 6317c478bd9Sstevel@tonic-gate Fct * 6327c478bd9Sstevel@tonic-gate are_u_this(Rej_desc *rej, int fd, struct stat *status, const char *name) 6337c478bd9Sstevel@tonic-gate { 6347c478bd9Sstevel@tonic-gate int i; 6357c478bd9Sstevel@tonic-gate char *maddr = 0; 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate fmap->fm_fsize = status->st_size; 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate /* 6407c478bd9Sstevel@tonic-gate * If this is a directory (which can't be mmap()'ed) generate a precise 6417c478bd9Sstevel@tonic-gate * error message. 6427c478bd9Sstevel@tonic-gate */ 6437c478bd9Sstevel@tonic-gate if ((status->st_mode & S_IFMT) == S_IFDIR) { 6447c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_STR; 6457c478bd9Sstevel@tonic-gate rej->rej_str = strerror(EISDIR); 6467c478bd9Sstevel@tonic-gate return (0); 6477c478bd9Sstevel@tonic-gate } 6487c478bd9Sstevel@tonic-gate 6497c478bd9Sstevel@tonic-gate /* 6507c478bd9Sstevel@tonic-gate * Map in the first page of the file. When this buffer is first used, 6517c478bd9Sstevel@tonic-gate * the mapping is a single system page. This is typically enough to 6527c478bd9Sstevel@tonic-gate * inspect the ehdr and phdrs of the file, and can be reused for each 6537c478bd9Sstevel@tonic-gate * file that get loaded. If a larger mapping is required to read the 6547c478bd9Sstevel@tonic-gate * ehdr and phdrs, a new mapping is created (see elf_map_it()). This 6557c478bd9Sstevel@tonic-gate * new mapping is again used for each new file loaded. Some objects, 6567c478bd9Sstevel@tonic-gate * such as filters, only take up one page, and in this case this mapping 6577c478bd9Sstevel@tonic-gate * will suffice for the file. 6587c478bd9Sstevel@tonic-gate */ 6597c478bd9Sstevel@tonic-gate maddr = mmap(fmap->fm_maddr, fmap->fm_msize, (PROT_READ | PROT_EXEC), 6607c478bd9Sstevel@tonic-gate fmap->fm_mflags, fd, 0); 6617c478bd9Sstevel@tonic-gate #if defined(MAP_ALIGN) 6627c478bd9Sstevel@tonic-gate if ((maddr == MAP_FAILED) && (errno == EINVAL)) { 6637c478bd9Sstevel@tonic-gate /* 6647c478bd9Sstevel@tonic-gate * If the mapping failed, and we used MAP_ALIGN, assume we're 6657c478bd9Sstevel@tonic-gate * on a system that doesn't support this option. Try again 6667c478bd9Sstevel@tonic-gate * without MAP_ALIGN. 6677c478bd9Sstevel@tonic-gate */ 6687c478bd9Sstevel@tonic-gate if (fmap->fm_mflags & MAP_ALIGN) { 6697c478bd9Sstevel@tonic-gate rtld_flags2 |= RT_FL2_NOMALIGN; 6707c478bd9Sstevel@tonic-gate fmap_setup(); 6717c478bd9Sstevel@tonic-gate 6727c478bd9Sstevel@tonic-gate maddr = (char *)mmap(fmap->fm_maddr, fmap->fm_msize, 6737c478bd9Sstevel@tonic-gate (PROT_READ | PROT_EXEC), fmap->fm_mflags, fd, 0); 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate } 6767c478bd9Sstevel@tonic-gate #endif 6777c478bd9Sstevel@tonic-gate if (maddr == MAP_FAILED) { 6787c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_STR; 6797c478bd9Sstevel@tonic-gate rej->rej_str = strerror(errno); 6807c478bd9Sstevel@tonic-gate return (0); 6817c478bd9Sstevel@tonic-gate } 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate /* 6847c478bd9Sstevel@tonic-gate * From now on we will re-use fmap->fm_maddr as the mapping address 6857c478bd9Sstevel@tonic-gate * so we augment the flags with MAP_FIXED and drop any MAP_ALIGN. 6867c478bd9Sstevel@tonic-gate */ 6877c478bd9Sstevel@tonic-gate fmap->fm_maddr = maddr; 6887c478bd9Sstevel@tonic-gate fmap->fm_mflags |= MAP_FIXED; 6897c478bd9Sstevel@tonic-gate #if defined(MAP_ALIGN) 6907c478bd9Sstevel@tonic-gate fmap->fm_mflags &= ~MAP_ALIGN; 6917c478bd9Sstevel@tonic-gate #endif 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate /* 6947c478bd9Sstevel@tonic-gate * Search through the object vectors to determine what kind of 6957c478bd9Sstevel@tonic-gate * object we have. 6967c478bd9Sstevel@tonic-gate */ 6977c478bd9Sstevel@tonic-gate for (i = 0; vector[i]; i++) { 6987c478bd9Sstevel@tonic-gate if ((vector[i]->fct_are_u_this)(rej)) 6997c478bd9Sstevel@tonic-gate return (vector[i]); 7007c478bd9Sstevel@tonic-gate else if (rej->rej_type) { 7017c478bd9Sstevel@tonic-gate Rt_map *lmp; 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate /* 7047c478bd9Sstevel@tonic-gate * If this object is an explicitly defined shared 7057c478bd9Sstevel@tonic-gate * object under inspection by ldd, and contains a 7067c478bd9Sstevel@tonic-gate * incompatible hardware capabilities requirement, then 7077c478bd9Sstevel@tonic-gate * inform the user, but continue processing. 7087c478bd9Sstevel@tonic-gate * 7097c478bd9Sstevel@tonic-gate * XXXX - ldd -v for any rej failure. 7107c478bd9Sstevel@tonic-gate */ 7117c478bd9Sstevel@tonic-gate if ((rej->rej_type == SGS_REJ_HWCAP_1) && 7127c478bd9Sstevel@tonic-gate (lml_main.lm_flags & LML_FLG_TRC_LDDSTUB) && 7137c478bd9Sstevel@tonic-gate ((lmp = lml_main.lm_head) != 0) && 7147c478bd9Sstevel@tonic-gate (FLAGS1(lmp) & FL1_RT_LDDSTUB) && 7157c478bd9Sstevel@tonic-gate (NEXT(lmp) == 0)) { 7167c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_GEN_HWCAP_1), 7177c478bd9Sstevel@tonic-gate name, rej->rej_str); 7187c478bd9Sstevel@tonic-gate return (vector[i]); 7197c478bd9Sstevel@tonic-gate } 7207c478bd9Sstevel@tonic-gate return (0); 7217c478bd9Sstevel@tonic-gate } 7227c478bd9Sstevel@tonic-gate } 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate /* 7257c478bd9Sstevel@tonic-gate * Unknown file type. 7267c478bd9Sstevel@tonic-gate */ 7277c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_UNKFILE; 7287c478bd9Sstevel@tonic-gate return (0); 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate 7327c478bd9Sstevel@tonic-gate /* 7337c478bd9Sstevel@tonic-gate * Function that determines whether a file name has already been loaded; if so, 7347c478bd9Sstevel@tonic-gate * returns a pointer to its link map structure; else returns a NULL pointer. 7357c478bd9Sstevel@tonic-gate */ 7367c478bd9Sstevel@tonic-gate static int 7377c478bd9Sstevel@tonic-gate _is_so_matched(const char *name, const char *str, int base) 7387c478bd9Sstevel@tonic-gate { 7397c478bd9Sstevel@tonic-gate const char *_str; 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate if (base && ((_str = strrchr(str, '/')) != NULL)) 7427c478bd9Sstevel@tonic-gate _str++; 7437c478bd9Sstevel@tonic-gate else 7447c478bd9Sstevel@tonic-gate _str = str; 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate return (strcmp(name, _str)); 7477c478bd9Sstevel@tonic-gate } 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate static Rt_map * 7507c478bd9Sstevel@tonic-gate is_so_matched(Rt_map *lmp, const char *name, int base) 7517c478bd9Sstevel@tonic-gate { 7527c478bd9Sstevel@tonic-gate Aliste off; 7537c478bd9Sstevel@tonic-gate const char **cpp; 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate /* 7567c478bd9Sstevel@tonic-gate * Typically, dependencies are specified as simple file names 7577c478bd9Sstevel@tonic-gate * (DT_NEEDED == libc.so.1), which are expanded to full pathnames to 7587c478bd9Sstevel@tonic-gate * open the file. The full pathname is NAME(), and the original name 7597c478bd9Sstevel@tonic-gate * is maintained on the ALIAS() list. Look through the ALIAS list first, 7607c478bd9Sstevel@tonic-gate * as this is most likely to match other dependency uses. 7617c478bd9Sstevel@tonic-gate */ 7627c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(ALIAS(lmp), off, cpp)) { 7637c478bd9Sstevel@tonic-gate if (_is_so_matched(name, *cpp, base) == 0) 7647c478bd9Sstevel@tonic-gate return (lmp); 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate /* 7687c478bd9Sstevel@tonic-gate * Finally compare full paths, this is sometimes useful for catching 7697c478bd9Sstevel@tonic-gate * filter names, or for those that dlopen() the dynamic executable. 7707c478bd9Sstevel@tonic-gate */ 7717c478bd9Sstevel@tonic-gate if (_is_so_matched(name, NAME(lmp), base) == 0) 7727c478bd9Sstevel@tonic-gate return (lmp); 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate if (PATHNAME(lmp) != NAME(lmp)) { 7757c478bd9Sstevel@tonic-gate if (_is_so_matched(name, PATHNAME(lmp), base) == 0) 7767c478bd9Sstevel@tonic-gate return (lmp); 7777c478bd9Sstevel@tonic-gate } 7787c478bd9Sstevel@tonic-gate return (0); 7797c478bd9Sstevel@tonic-gate } 7807c478bd9Sstevel@tonic-gate 7817c478bd9Sstevel@tonic-gate Rt_map * 7827c478bd9Sstevel@tonic-gate is_so_loaded(Lm_list *lml, const char *name, int base) 7837c478bd9Sstevel@tonic-gate { 7847c478bd9Sstevel@tonic-gate Rt_map *lmp; 7857c478bd9Sstevel@tonic-gate const char *_name; 7867c478bd9Sstevel@tonic-gate avl_index_t where; 7877c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 7887c478bd9Sstevel@tonic-gate Aliste off; 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate /* 7917c478bd9Sstevel@tonic-gate * If we've been asked to do a basename search, first determine if 7927c478bd9Sstevel@tonic-gate * the pathname is registered in the FullpathNode AVL tree. 7937c478bd9Sstevel@tonic-gate */ 7947c478bd9Sstevel@tonic-gate if (base && (name[0] == '/') && 7957c478bd9Sstevel@tonic-gate ((lmp = fpavl_loaded(lml, name, &where)) != NULL) && 7967c478bd9Sstevel@tonic-gate ((FLAGS(lmp) & (FLG_RT_OBJECT | FLG_RT_DELETE)) == 0)) 7977c478bd9Sstevel@tonic-gate return (lmp); 7987c478bd9Sstevel@tonic-gate 7997c478bd9Sstevel@tonic-gate /* 8007c478bd9Sstevel@tonic-gate * If we've been asked to do a basename search reduce the input name 8017c478bd9Sstevel@tonic-gate * to its basename. 8027c478bd9Sstevel@tonic-gate */ 8037c478bd9Sstevel@tonic-gate if (base && ((_name = strrchr(name, '/')) != NULL)) 8047c478bd9Sstevel@tonic-gate _name++; 8057c478bd9Sstevel@tonic-gate else 8067c478bd9Sstevel@tonic-gate _name = name; 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate /* 8097c478bd9Sstevel@tonic-gate * Loop through the callers link-map lists. 8107c478bd9Sstevel@tonic-gate */ 8117c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(lml->lm_lists, off, lmc)) { 8127c478bd9Sstevel@tonic-gate for (lmp = lmc->lc_head; lmp; lmp = (Rt_map *)NEXT(lmp)) { 8137c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & (FLG_RT_OBJECT | FLG_RT_DELETE)) 8147c478bd9Sstevel@tonic-gate continue; 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate if (is_so_matched(lmp, _name, base)) 8177c478bd9Sstevel@tonic-gate return (lmp); 8187c478bd9Sstevel@tonic-gate } 8197c478bd9Sstevel@tonic-gate } 8207c478bd9Sstevel@tonic-gate return ((Rt_map *)0); 8217c478bd9Sstevel@tonic-gate } 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate /* 8257c478bd9Sstevel@tonic-gate * Tracing is enabled by the LD_TRACE_LOADED_OPTIONS environment variable which 8267c478bd9Sstevel@tonic-gate * is normally set from ldd(1). For each link map we load, print the load name 8277c478bd9Sstevel@tonic-gate * and the full pathname of the shared object. 8287c478bd9Sstevel@tonic-gate */ 8297c478bd9Sstevel@tonic-gate /* ARGSUSED4 */ 8307c478bd9Sstevel@tonic-gate static void 8317c478bd9Sstevel@tonic-gate trace_so(Rt_map *clmp, Rej_desc *rej, const char *name, const char *path, 8327c478bd9Sstevel@tonic-gate int alter, const char *nfound) 8337c478bd9Sstevel@tonic-gate { 8347c478bd9Sstevel@tonic-gate const char *str = MSG_ORIG(MSG_STR_EMPTY); 8357c478bd9Sstevel@tonic-gate const char *reject = MSG_ORIG(MSG_STR_EMPTY); 8367c478bd9Sstevel@tonic-gate char _reject[PATH_MAX]; 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate /* 8397c478bd9Sstevel@tonic-gate * The first time through trace_so() will only have lddstub on the 8407c478bd9Sstevel@tonic-gate * link-map list and the preloaded shared object is supplied as "path". 8417c478bd9Sstevel@tonic-gate * As we don't want to print this shared object as a dependency, but 8427c478bd9Sstevel@tonic-gate * instead inspect *its* dependencies, return. 8437c478bd9Sstevel@tonic-gate */ 8447c478bd9Sstevel@tonic-gate if (FLAGS1(clmp) & FL1_RT_LDDSTUB) 8457c478bd9Sstevel@tonic-gate return; 8467c478bd9Sstevel@tonic-gate 8477c478bd9Sstevel@tonic-gate /* 8487c478bd9Sstevel@tonic-gate * Without any rejection info, this is a supplied not-found condition. 8497c478bd9Sstevel@tonic-gate */ 8507c478bd9Sstevel@tonic-gate if (rej && (rej->rej_type == 0)) { 8517c478bd9Sstevel@tonic-gate (void) printf(nfound, name); 8527c478bd9Sstevel@tonic-gate return; 8537c478bd9Sstevel@tonic-gate } 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate /* 8567c478bd9Sstevel@tonic-gate * If rejection information exists then establish what object was 8577c478bd9Sstevel@tonic-gate * found and the reason for its rejection. 8587c478bd9Sstevel@tonic-gate */ 8597c478bd9Sstevel@tonic-gate if (rej) { 8607c478bd9Sstevel@tonic-gate /* LINTED */ 8617c478bd9Sstevel@tonic-gate (void) snprintf(_reject, PATH_MAX, 862*5aefb655Srie MSG_INTL(ldd_reject[rej->rej_type]), conv_reject_desc(rej)); 8637c478bd9Sstevel@tonic-gate if (rej->rej_name) 8647c478bd9Sstevel@tonic-gate path = rej->rej_name; 8657c478bd9Sstevel@tonic-gate reject = (char *)_reject; 8667c478bd9Sstevel@tonic-gate 8677c478bd9Sstevel@tonic-gate /* 8687c478bd9Sstevel@tonic-gate * Was an alternative pathname defined (from a configuration 8697c478bd9Sstevel@tonic-gate * file). 8707c478bd9Sstevel@tonic-gate */ 8717c478bd9Sstevel@tonic-gate if (rej->rej_flag & FLG_FD_ALTER) 8727c478bd9Sstevel@tonic-gate str = MSG_INTL(MSG_LDD_FIL_ALTER); 8737c478bd9Sstevel@tonic-gate } else { 8747c478bd9Sstevel@tonic-gate if (alter) 8757c478bd9Sstevel@tonic-gate str = MSG_INTL(MSG_LDD_FIL_ALTER); 8767c478bd9Sstevel@tonic-gate } 8777c478bd9Sstevel@tonic-gate 8787c478bd9Sstevel@tonic-gate /* 8797c478bd9Sstevel@tonic-gate * If the load name isn't a full pathname print its associated pathname 8807c478bd9Sstevel@tonic-gate * together with all the other information we've gathered. 8817c478bd9Sstevel@tonic-gate */ 8827c478bd9Sstevel@tonic-gate if (*name == '/') 8837c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), path, str, reject); 8847c478bd9Sstevel@tonic-gate else 8857c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), name, path, str, reject); 8867c478bd9Sstevel@tonic-gate } 8877c478bd9Sstevel@tonic-gate 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate /* 8907c478bd9Sstevel@tonic-gate * Establish a link-map mode, initializing it if it has just been loaded, or 8917c478bd9Sstevel@tonic-gate * potentially updating it if it already exists. 8927c478bd9Sstevel@tonic-gate */ 8937c478bd9Sstevel@tonic-gate int 8947c478bd9Sstevel@tonic-gate update_mode(Rt_map *lmp, int omode, int nmode) 8957c478bd9Sstevel@tonic-gate { 896dffec89cSrie Lm_list *lml = LIST(lmp); 8977c478bd9Sstevel@tonic-gate int pmode = 0; 8987c478bd9Sstevel@tonic-gate 8997c478bd9Sstevel@tonic-gate /* 9007c478bd9Sstevel@tonic-gate * A newly loaded object hasn't had its mode set yet. Modes are used to 9017c478bd9Sstevel@tonic-gate * load dependencies, so don't propagate any parent or no-load flags, as 9027c478bd9Sstevel@tonic-gate * these would adversely affect this objects ability to load any of its 9037c478bd9Sstevel@tonic-gate * dependencies that aren't already loaded. RTLD_FIRST is applicable to 9047c478bd9Sstevel@tonic-gate * this objects handle creation only, and should not be propagated. 9057c478bd9Sstevel@tonic-gate */ 9067c478bd9Sstevel@tonic-gate if ((FLAGS(lmp) & FLG_RT_MODESET) == 0) { 9077c478bd9Sstevel@tonic-gate MODE(lmp) |= nmode & ~(RTLD_PARENT | RTLD_NOLOAD | RTLD_FIRST); 9087c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_MODESET; 9097c478bd9Sstevel@tonic-gate return (1); 9107c478bd9Sstevel@tonic-gate } 9117c478bd9Sstevel@tonic-gate 9127c478bd9Sstevel@tonic-gate /* 9137c478bd9Sstevel@tonic-gate * Establish any new overriding modes. RTLD_LAZY and RTLD_NOW should be 9147c478bd9Sstevel@tonic-gate * represented individually (this is historic, as these two flags were 9157c478bd9Sstevel@tonic-gate * the only flags originally available to dlopen()). Other flags are 9167c478bd9Sstevel@tonic-gate * accumulative, but have a hierarchy of preference. 9177c478bd9Sstevel@tonic-gate */ 9187c478bd9Sstevel@tonic-gate if ((omode & RTLD_LAZY) && (nmode & RTLD_NOW)) { 9197c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_LAZY; 9207c478bd9Sstevel@tonic-gate pmode |= RTLD_NOW; 9217c478bd9Sstevel@tonic-gate } 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate pmode |= ((~omode & nmode) & 9247c478bd9Sstevel@tonic-gate (RTLD_GLOBAL | RTLD_WORLD | RTLD_NODELETE)); 9257c478bd9Sstevel@tonic-gate if (pmode) { 926*5aefb655Srie DBG_CALL(Dbg_file_mode_promote(lmp, pmode)); 9277c478bd9Sstevel@tonic-gate MODE(lmp) |= pmode; 9287c478bd9Sstevel@tonic-gate } 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate /* 9317c478bd9Sstevel@tonic-gate * If this load is an RTLD_NOW request and the object has already been 9327c478bd9Sstevel@tonic-gate * loaded non-RTLD_NOW, append this object to the relocation-now list 9337c478bd9Sstevel@tonic-gate * of the objects associated control list. Note, if the object hasn't 9347c478bd9Sstevel@tonic-gate * yet been relocated, setting its MODE() to RTLD_NOW will establish 9357c478bd9Sstevel@tonic-gate * full relocation processing when it eventually gets relocated. 9367c478bd9Sstevel@tonic-gate */ 9377c478bd9Sstevel@tonic-gate if ((pmode & RTLD_NOW) && 9387c478bd9Sstevel@tonic-gate (FLAGS(lmp) & (FLG_RT_RELOCED | FLG_RT_RELOCING))) { 9397c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 9407c478bd9Sstevel@tonic-gate 9417c478bd9Sstevel@tonic-gate /* LINTED */ 9427c478bd9Sstevel@tonic-gate lmc = (Lm_cntl *)((char *)(LIST(lmp)->lm_lists) + CNTL(lmp)); 9437c478bd9Sstevel@tonic-gate (void) alist_append(&(lmc->lc_now), &lmp, sizeof (Rt_map *), 9447c478bd9Sstevel@tonic-gate AL_CNT_LMNOW); 9457c478bd9Sstevel@tonic-gate } 9467c478bd9Sstevel@tonic-gate 9477c478bd9Sstevel@tonic-gate #ifdef SIEBEL_DISABLE 9487c478bd9Sstevel@tonic-gate /* 9497c478bd9Sstevel@tonic-gate * For patch backward compatibility the following .init collection 9507c478bd9Sstevel@tonic-gate * is disabled. 9517c478bd9Sstevel@tonic-gate */ 9527c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_DISFIX_1) 9537c478bd9Sstevel@tonic-gate return (pmode); 9547c478bd9Sstevel@tonic-gate #endif 9557c478bd9Sstevel@tonic-gate 9567c478bd9Sstevel@tonic-gate /* 957dffec89cSrie * If this objects .init has been collected but has not yet been called, 958dffec89cSrie * it may be necessary to reevaluate the object using tsort(). For 9597c478bd9Sstevel@tonic-gate * example, a new dlopen() hierarchy may bind to uninitialized objects 9607c478bd9Sstevel@tonic-gate * that are already loaded, or a dlopen(RTLD_NOW) can establish new 9617c478bd9Sstevel@tonic-gate * bindings between already loaded objects that require the tsort() 962dffec89cSrie * information be recomputed. If however, no new objects have been 963dffec89cSrie * added to the process, and this object hasn't been promoted, don't 964dffec89cSrie * bother reevaluating the .init. The present tsort() information is 965dffec89cSrie * probably as accurate as necessary, and by not establishing a parallel 966dffec89cSrie * tsort() we can help reduce the amount of recursion possible between 967dffec89cSrie * .inits. 9687c478bd9Sstevel@tonic-gate */ 969dffec89cSrie if (((FLAGS(lmp) & 970dffec89cSrie (FLG_RT_INITCLCT | FLG_RT_INITCALL)) == FLG_RT_INITCLCT) && 971dffec89cSrie ((lml->lm_flags & LML_FLG_OBJADDED) || ((pmode & RTLD_NOW) && 972dffec89cSrie (FLAGS(lmp) & (FLG_RT_RELOCED | FLG_RT_RELOCING))))) { 9737c478bd9Sstevel@tonic-gate FLAGS(lmp) &= ~FLG_RT_INITCLCT; 9747c478bd9Sstevel@tonic-gate LIST(lmp)->lm_init++; 975dffec89cSrie LIST(lmp)->lm_flags |= LML_FLG_OBJREEVAL; 9767c478bd9Sstevel@tonic-gate } 9777c478bd9Sstevel@tonic-gate 9787c478bd9Sstevel@tonic-gate return (pmode); 9797c478bd9Sstevel@tonic-gate } 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate /* 9827c478bd9Sstevel@tonic-gate * Determine whether an alias name already exists, and if not create one. This 9837c478bd9Sstevel@tonic-gate * is typically used to retain dependency names, such as "libc.so.1", which 9847c478bd9Sstevel@tonic-gate * would have been expanded to full path names when they were loaded. The 9857c478bd9Sstevel@tonic-gate * full path names (NAME() and possibly PATHNAME()) are maintained as Fullpath 9867c478bd9Sstevel@tonic-gate * AVL nodes, and thus would have been matched by fpavl_loaded() during 9877c478bd9Sstevel@tonic-gate * file_open(). 9887c478bd9Sstevel@tonic-gate */ 9897c478bd9Sstevel@tonic-gate int 9907c478bd9Sstevel@tonic-gate append_alias(Rt_map *lmp, const char *str, int *added) 9917c478bd9Sstevel@tonic-gate { 9927c478bd9Sstevel@tonic-gate Aliste off; 9937c478bd9Sstevel@tonic-gate char **cpp, *cp; 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate /* 9967c478bd9Sstevel@tonic-gate * Determine if this filename is already on the alias list. 9977c478bd9Sstevel@tonic-gate */ 9987c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(ALIAS(lmp), off, cpp)) { 9997c478bd9Sstevel@tonic-gate if (strcmp(*cpp, str) == 0) 10007c478bd9Sstevel@tonic-gate return (1); 10017c478bd9Sstevel@tonic-gate } 10027c478bd9Sstevel@tonic-gate 10037c478bd9Sstevel@tonic-gate /* 10047c478bd9Sstevel@tonic-gate * This is a new alias, append it to the alias list. 10057c478bd9Sstevel@tonic-gate */ 10067c478bd9Sstevel@tonic-gate if ((cp = strdup(str)) == 0) 10077c478bd9Sstevel@tonic-gate return (0); 10087c478bd9Sstevel@tonic-gate 10097c478bd9Sstevel@tonic-gate if (alist_append(&ALIAS(lmp), &cp, sizeof (char *), 10107c478bd9Sstevel@tonic-gate AL_CNT_ALIAS) == 0) { 10117c478bd9Sstevel@tonic-gate free(cp); 10127c478bd9Sstevel@tonic-gate return (0); 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate if (added) 10157c478bd9Sstevel@tonic-gate *added = 1; 10167c478bd9Sstevel@tonic-gate return (1); 10177c478bd9Sstevel@tonic-gate } 10187c478bd9Sstevel@tonic-gate 10197c478bd9Sstevel@tonic-gate /* 10207c478bd9Sstevel@tonic-gate * Determine whether a file is already loaded by comparing device and inode 10217c478bd9Sstevel@tonic-gate * values. 10227c478bd9Sstevel@tonic-gate */ 10237c478bd9Sstevel@tonic-gate static Rt_map * 10247c478bd9Sstevel@tonic-gate is_devinode_loaded(struct stat *status, Lm_list *lml, const char *name, 10257c478bd9Sstevel@tonic-gate uint_t flags) 10267c478bd9Sstevel@tonic-gate { 10277c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 10287c478bd9Sstevel@tonic-gate Aliste off; 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate /* 10317c478bd9Sstevel@tonic-gate * If this is an auditor, it will have been opened on a new link-map. 10327c478bd9Sstevel@tonic-gate * To prevent multiple occurrances of the same auditor on multiple 10337c478bd9Sstevel@tonic-gate * link-maps, search the head of each link-map list and see if this 10347c478bd9Sstevel@tonic-gate * object is already loaded as an auditor. 10357c478bd9Sstevel@tonic-gate */ 10367c478bd9Sstevel@tonic-gate if (flags & FLG_RT_AUDIT) { 10377c478bd9Sstevel@tonic-gate Lm_list * lml; 10387c478bd9Sstevel@tonic-gate Listnode * lnp; 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&dynlm_list, lnp, 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 } 10497c478bd9Sstevel@tonic-gate return ((Rt_map *)0); 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 */ 10577c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(lml->lm_lists, off, lmc)) { 10587c478bd9Sstevel@tonic-gate Rt_map *nlmp; 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate for (nlmp = lmc->lc_head; nlmp; nlmp = (Rt_map *)NEXT(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) { 10707c478bd9Sstevel@tonic-gate if (*name == '/') 10717c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), 10727c478bd9Sstevel@tonic-gate name, MSG_ORIG(MSG_STR_EMPTY), 10737c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 10747c478bd9Sstevel@tonic-gate else 10757c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), 10767c478bd9Sstevel@tonic-gate name, NAME(nlmp), 10777c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY), 10787c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 10797c478bd9Sstevel@tonic-gate } 10807c478bd9Sstevel@tonic-gate return (nlmp); 10817c478bd9Sstevel@tonic-gate } 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate return ((Rt_map *)0); 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate /* 10877c478bd9Sstevel@tonic-gate * Generate any error messages indicating a file could not be found. When 10887c478bd9Sstevel@tonic-gate * preloading or auditing a secure application, it can be a little more helpful 10897c478bd9Sstevel@tonic-gate * to indicate that a search of secure directories has failed, so adjust the 10907c478bd9Sstevel@tonic-gate * messages accordingly. 10917c478bd9Sstevel@tonic-gate */ 10927c478bd9Sstevel@tonic-gate void 10937c478bd9Sstevel@tonic-gate file_notfound(Lm_list *lml, const char *name, Rt_map *clmp, uint_t flags, 10947c478bd9Sstevel@tonic-gate Rej_desc * rej) 10957c478bd9Sstevel@tonic-gate { 10967c478bd9Sstevel@tonic-gate int secure = 0; 10977c478bd9Sstevel@tonic-gate 10987c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SECURE) && 10997c478bd9Sstevel@tonic-gate (flags & (FLG_RT_PRELOAD | FLG_RT_AUDIT))) 11007c478bd9Sstevel@tonic-gate secure++; 11017c478bd9Sstevel@tonic-gate 11027c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) { 11037c478bd9Sstevel@tonic-gate /* 11047c478bd9Sstevel@tonic-gate * Under ldd(1), auxiliary filtees that can't be loaded are 11057c478bd9Sstevel@tonic-gate * ignored, unless verbose errors are requested. 11067c478bd9Sstevel@tonic-gate */ 11077c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_SILENCERR) && 11087c478bd9Sstevel@tonic-gate ((lml->lm_flags & LML_FLG_TRC_VERBOSE) == 0)) 11097c478bd9Sstevel@tonic-gate return; 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate if (secure) 11127c478bd9Sstevel@tonic-gate trace_so(clmp, rej, name, 0, 0, 11137c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_SEC_NFOUND)); 11147c478bd9Sstevel@tonic-gate else 11157c478bd9Sstevel@tonic-gate trace_so(clmp, rej, name, 0, 0, 11167c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_FIL_NFOUND)); 11177c478bd9Sstevel@tonic-gate return; 11187c478bd9Sstevel@tonic-gate } 11197c478bd9Sstevel@tonic-gate 11207c478bd9Sstevel@tonic-gate if (rej->rej_type) { 1121*5aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(err_reject[rej->rej_type]), 11227c478bd9Sstevel@tonic-gate rej->rej_name ? rej->rej_name : MSG_INTL(MSG_STR_UNKNOWN), 1123*5aefb655Srie conv_reject_desc(rej)); 11247c478bd9Sstevel@tonic-gate return; 11257c478bd9Sstevel@tonic-gate } 11267c478bd9Sstevel@tonic-gate 11277c478bd9Sstevel@tonic-gate if (secure) 1128*5aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SEC_OPEN), name); 11297c478bd9Sstevel@tonic-gate else 1130*5aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), name, 11317c478bd9Sstevel@tonic-gate strerror(ENOENT)); 11327c478bd9Sstevel@tonic-gate } 11337c478bd9Sstevel@tonic-gate 11347c478bd9Sstevel@tonic-gate static int 11357c478bd9Sstevel@tonic-gate file_open(int err, Lm_list *lml, const char *oname, const char *nname, 11367c478bd9Sstevel@tonic-gate Rt_map *clmp, uint_t flags, Fdesc * fdesc, Rej_desc *rej) 11377c478bd9Sstevel@tonic-gate { 11387c478bd9Sstevel@tonic-gate struct stat status; 11397c478bd9Sstevel@tonic-gate Rt_map *nlmp; 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate fdesc->fd_oname = oname; 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate if ((err == 0) && (fdesc->fd_flags & FLG_FD_ALTER)) 1144*5aefb655Srie DBG_CALL(Dbg_file_config_obj(lml, oname, 0, nname)); 11457c478bd9Sstevel@tonic-gate 11467c478bd9Sstevel@tonic-gate /* 11477c478bd9Sstevel@tonic-gate * If we're dealing with a full pathname, determine whether this 11487c478bd9Sstevel@tonic-gate * pathname is already known. Other pathnames fall through to the 11497c478bd9Sstevel@tonic-gate * dev/inode check, as even though the pathname may look the same as 11507c478bd9Sstevel@tonic-gate * one previously used, the process may have changed directory. 11517c478bd9Sstevel@tonic-gate */ 11527c478bd9Sstevel@tonic-gate if ((err == 0) && (nname[0] == '/')) { 11537c478bd9Sstevel@tonic-gate if ((nlmp = fpavl_loaded(lml, nname, 11547c478bd9Sstevel@tonic-gate &(fdesc->fd_avlwhere))) != NULL) { 11557c478bd9Sstevel@tonic-gate fdesc->fd_nname = nname; 11567c478bd9Sstevel@tonic-gate fdesc->fd_lmp = nlmp; 11577c478bd9Sstevel@tonic-gate return (1); 11587c478bd9Sstevel@tonic-gate } 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate if ((err == 0) && ((stat(nname, &status)) != -1)) { 11627c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 11637c478bd9Sstevel@tonic-gate int fd, size, added; 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate /* 11667c478bd9Sstevel@tonic-gate * If this path has been constructed as part of expanding a 11677c478bd9Sstevel@tonic-gate * HWCAP directory, ignore any subdirectories. For any other 11687c478bd9Sstevel@tonic-gate * reference that expands to a directory, fall through to 11697c478bd9Sstevel@tonic-gate * contruct a meaningful rejection message. 11707c478bd9Sstevel@tonic-gate */ 11717c478bd9Sstevel@tonic-gate if ((flags & FLG_RT_HWCAP) && 11727c478bd9Sstevel@tonic-gate ((status.st_mode & S_IFMT) == S_IFDIR)) 11737c478bd9Sstevel@tonic-gate return (0); 11747c478bd9Sstevel@tonic-gate 11757c478bd9Sstevel@tonic-gate /* 11767c478bd9Sstevel@tonic-gate * Resolve the filename and determine whether the resolved name 11777c478bd9Sstevel@tonic-gate * is already known. Typically, the previous fpavl_loaded() 11787c478bd9Sstevel@tonic-gate * will have caught this, as both NAME() and PATHNAME() for a 11797c478bd9Sstevel@tonic-gate * link-map are recorded in the FullNode AVL tree. However, 11807c478bd9Sstevel@tonic-gate * instances exist where a file can be replaced (loop-back 11817c478bd9Sstevel@tonic-gate * mounts, bfu, etc.), and reference is made to the original 11827c478bd9Sstevel@tonic-gate * file through a symbolic link. By checking the pathname here, 11837c478bd9Sstevel@tonic-gate * we don't fall through to the dev/inode check and conclude 11847c478bd9Sstevel@tonic-gate * that a new file should be loaded. 11857c478bd9Sstevel@tonic-gate */ 11867c478bd9Sstevel@tonic-gate if ((nname[0] == '/') && (rtld_flags & RT_FL_EXECNAME) && 11877c478bd9Sstevel@tonic-gate ((size = resolvepath(nname, path, (PATH_MAX - 1))) > 0)) { 11887c478bd9Sstevel@tonic-gate path[size] = '\0'; 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate if (strcmp(nname, path)) { 119124a6229eSrie if ((nlmp = 119224a6229eSrie fpavl_loaded(lml, path, 0)) != NULL) { 11937c478bd9Sstevel@tonic-gate added = 0; 11947c478bd9Sstevel@tonic-gate 11957c478bd9Sstevel@tonic-gate if (append_alias(nlmp, nname, 11967c478bd9Sstevel@tonic-gate &added) == 0) 11977c478bd9Sstevel@tonic-gate return (0); 11987c478bd9Sstevel@tonic-gate if (added) 1199*5aefb655Srie DBG_CALL(Dbg_file_skip(LIST(nlmp), 1200*5aefb655Srie NAME(nlmp), nname)); 12017c478bd9Sstevel@tonic-gate fdesc->fd_nname = nname; 12027c478bd9Sstevel@tonic-gate fdesc->fd_lmp = nlmp; 12037c478bd9Sstevel@tonic-gate return (1); 12047c478bd9Sstevel@tonic-gate } 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate /* 12077c478bd9Sstevel@tonic-gate * If this pathname hasn't been loaded, save 12087c478bd9Sstevel@tonic-gate * the resolved pathname so that it doesn't 12097c478bd9Sstevel@tonic-gate * have to be recomputed as part of fullpath() 12107c478bd9Sstevel@tonic-gate * processing. 12117c478bd9Sstevel@tonic-gate */ 12127c478bd9Sstevel@tonic-gate if ((fdesc->fd_pname = strdup(path)) == 0) 12137c478bd9Sstevel@tonic-gate return (0); 12147c478bd9Sstevel@tonic-gate } else { 12157c478bd9Sstevel@tonic-gate /* 12167c478bd9Sstevel@tonic-gate * If the resolved name doesn't differ from the 12177c478bd9Sstevel@tonic-gate * original, save it without duplication. 12187c478bd9Sstevel@tonic-gate * Having fd_pname set indicates that no further 12197c478bd9Sstevel@tonic-gate * resolvepath processing is necessary. 12207c478bd9Sstevel@tonic-gate */ 12217c478bd9Sstevel@tonic-gate fdesc->fd_pname = nname; 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate } 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate if (nlmp = is_devinode_loaded(&status, lml, nname, flags)) { 12267c478bd9Sstevel@tonic-gate added = 0; 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate if (append_alias(nlmp, nname, &added) == 0) 12297c478bd9Sstevel@tonic-gate return (0); 12307c478bd9Sstevel@tonic-gate if (added) { 12317c478bd9Sstevel@tonic-gate if ((nname[0] == '/') && (fpavl_insert(lml, 12327c478bd9Sstevel@tonic-gate nlmp, nname, 0) == 0)) 12337c478bd9Sstevel@tonic-gate return (0); 1234*5aefb655Srie DBG_CALL(Dbg_file_skip(LIST(nlmp), NAME(nlmp), 1235*5aefb655Srie nname)); 12367c478bd9Sstevel@tonic-gate } 12377c478bd9Sstevel@tonic-gate fdesc->fd_nname = nname; 12387c478bd9Sstevel@tonic-gate fdesc->fd_lmp = nlmp; 12397c478bd9Sstevel@tonic-gate return (1); 12407c478bd9Sstevel@tonic-gate } 12417c478bd9Sstevel@tonic-gate 12427c478bd9Sstevel@tonic-gate if ((fd = open(nname, O_RDONLY, 0)) == -1) { 12437c478bd9Sstevel@tonic-gate /* 12447c478bd9Sstevel@tonic-gate * As the file must exist for the previous stat() to 12457c478bd9Sstevel@tonic-gate * have succeeded, record the error condition. 12467c478bd9Sstevel@tonic-gate */ 12477c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_STR; 12487c478bd9Sstevel@tonic-gate rej->rej_str = strerror(errno); 12497c478bd9Sstevel@tonic-gate } else { 12507c478bd9Sstevel@tonic-gate Fct *ftp; 12517c478bd9Sstevel@tonic-gate 12527c478bd9Sstevel@tonic-gate if ((ftp = are_u_this(rej, fd, &status, nname)) != 0) { 12537c478bd9Sstevel@tonic-gate fdesc->fd_nname = nname; 12547c478bd9Sstevel@tonic-gate fdesc->fd_ftp = ftp; 12557c478bd9Sstevel@tonic-gate fdesc->fd_dev = status.st_dev; 12567c478bd9Sstevel@tonic-gate fdesc->fd_ino = status.st_ino; 12577c478bd9Sstevel@tonic-gate fdesc->fd_fd = fd; 12587c478bd9Sstevel@tonic-gate 12597c478bd9Sstevel@tonic-gate /* 12607c478bd9Sstevel@tonic-gate * Trace that this open has succeeded. 12617c478bd9Sstevel@tonic-gate */ 12627c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) { 12637c478bd9Sstevel@tonic-gate trace_so(clmp, 0, oname, nname, 12647c478bd9Sstevel@tonic-gate (fdesc->fd_flags & FLG_FD_ALTER), 0); 12657c478bd9Sstevel@tonic-gate } 12667c478bd9Sstevel@tonic-gate return (1); 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate (void) close(fd); 12697c478bd9Sstevel@tonic-gate } 12707c478bd9Sstevel@tonic-gate 12717c478bd9Sstevel@tonic-gate } else if (errno != ENOENT) { 12727c478bd9Sstevel@tonic-gate /* 12737c478bd9Sstevel@tonic-gate * If the open() failed for anything other than the file not 12747c478bd9Sstevel@tonic-gate * existing, record the error condition. 12757c478bd9Sstevel@tonic-gate */ 12767c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_STR; 12777c478bd9Sstevel@tonic-gate rej->rej_str = strerror(errno); 12787c478bd9Sstevel@tonic-gate } 12797c478bd9Sstevel@tonic-gate 12807c478bd9Sstevel@tonic-gate /* 12817c478bd9Sstevel@tonic-gate * Indicate any rejection. 12827c478bd9Sstevel@tonic-gate */ 12837c478bd9Sstevel@tonic-gate if (rej->rej_type) { 12847c478bd9Sstevel@tonic-gate rej->rej_name = nname; 12857c478bd9Sstevel@tonic-gate rej->rej_flag = (fdesc->fd_flags & FLG_FD_ALTER); 1286*5aefb655Srie DBG_CALL(Dbg_file_rejected(lml, rej)); 12877c478bd9Sstevel@tonic-gate } 12887c478bd9Sstevel@tonic-gate return (0); 12897c478bd9Sstevel@tonic-gate } 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate /* 12927c478bd9Sstevel@tonic-gate * Find a full pathname (it contains a "/"). 12937c478bd9Sstevel@tonic-gate */ 12947c478bd9Sstevel@tonic-gate int 12957c478bd9Sstevel@tonic-gate find_path(Lm_list *lml, const char *oname, Rt_map *clmp, uint_t flags, 12967c478bd9Sstevel@tonic-gate Fdesc * fdesc, Rej_desc *rej) 12977c478bd9Sstevel@tonic-gate { 12987c478bd9Sstevel@tonic-gate int err = 0; 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate /* 13017c478bd9Sstevel@tonic-gate * If directory configuration exists determine if this path is known. 13027c478bd9Sstevel@tonic-gate */ 13037c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_DIRCFG) { 13047c478bd9Sstevel@tonic-gate Rtc_obj *obj; 13057c478bd9Sstevel@tonic-gate const char *aname; 13067c478bd9Sstevel@tonic-gate 13077c478bd9Sstevel@tonic-gate if ((obj = elf_config_ent(oname, (Word)elf_hash(oname), 13087c478bd9Sstevel@tonic-gate 0, &aname)) != 0) { 13097c478bd9Sstevel@tonic-gate /* 13107c478bd9Sstevel@tonic-gate * If the configuration file states that this path is a 13117c478bd9Sstevel@tonic-gate * directory, or the path is explicitly defined as 13127c478bd9Sstevel@tonic-gate * non-existent (ie. a unused platform specific 13137c478bd9Sstevel@tonic-gate * library), then go no further. 13147c478bd9Sstevel@tonic-gate */ 13157c478bd9Sstevel@tonic-gate if (obj->co_flags & RTC_OBJ_DIRENT) { 13167c478bd9Sstevel@tonic-gate err = EISDIR; 13177c478bd9Sstevel@tonic-gate } else if ((obj->co_flags & 13187c478bd9Sstevel@tonic-gate (RTC_OBJ_NOEXIST | RTC_OBJ_ALTER)) == 13197c478bd9Sstevel@tonic-gate RTC_OBJ_NOEXIST) { 13207c478bd9Sstevel@tonic-gate err = ENOENT; 13217c478bd9Sstevel@tonic-gate } else if ((obj->co_flags & RTC_OBJ_ALTER) && 13227c478bd9Sstevel@tonic-gate (rtld_flags & RT_FL_OBJALT) && (lml == &lml_main)) { 13237c478bd9Sstevel@tonic-gate int ret; 13247c478bd9Sstevel@tonic-gate 13257c478bd9Sstevel@tonic-gate fdesc->fd_flags |= FLG_FD_ALTER; 13267c478bd9Sstevel@tonic-gate /* 13277c478bd9Sstevel@tonic-gate * Attempt to open the alternative path. If 13287c478bd9Sstevel@tonic-gate * this fails, and the alternative is flagged 13297c478bd9Sstevel@tonic-gate * as optional, fall through to open the 13307c478bd9Sstevel@tonic-gate * original path. 13317c478bd9Sstevel@tonic-gate */ 1332*5aefb655Srie DBG_CALL(Dbg_libs_found(lml, aname, 1333*5aefb655Srie FLG_FD_ALTER)); 13347c478bd9Sstevel@tonic-gate if (((ret = file_open(0, lml, oname, aname, 13357c478bd9Sstevel@tonic-gate clmp, flags, fdesc, rej)) != 0) || 13367c478bd9Sstevel@tonic-gate ((obj->co_flags & RTC_OBJ_OPTINAL) == 0)) 13377c478bd9Sstevel@tonic-gate return (ret); 13387c478bd9Sstevel@tonic-gate 13397c478bd9Sstevel@tonic-gate fdesc->fd_flags &= ~FLG_FD_ALTER; 13407c478bd9Sstevel@tonic-gate } 13417c478bd9Sstevel@tonic-gate } 13427c478bd9Sstevel@tonic-gate } 1343*5aefb655Srie DBG_CALL(Dbg_libs_found(lml, oname, 0)); 13447c478bd9Sstevel@tonic-gate return (file_open(err, lml, oname, oname, clmp, flags, fdesc, rej)); 13457c478bd9Sstevel@tonic-gate } 13467c478bd9Sstevel@tonic-gate 13477c478bd9Sstevel@tonic-gate /* 13487c478bd9Sstevel@tonic-gate * Find a simple filename (it doesn't contain a "/"). 13497c478bd9Sstevel@tonic-gate */ 13507c478bd9Sstevel@tonic-gate static int 13517c478bd9Sstevel@tonic-gate _find_file(Lm_list *lml, const char *oname, const char *nname, Rt_map *clmp, 13527c478bd9Sstevel@tonic-gate uint_t flags, Fdesc * fdesc, Rej_desc *rej, Pnode * dir, int aflag) 13537c478bd9Sstevel@tonic-gate { 1354*5aefb655Srie DBG_CALL(Dbg_libs_found(lml, nname, aflag)); 13557c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_TRC_SEARCH) && 13567c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) { 13577c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_PTH_TRYING), nname, aflag ? 13587c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_FIL_ALTER) : MSG_ORIG(MSG_STR_EMPTY)); 13597c478bd9Sstevel@tonic-gate } 13607c478bd9Sstevel@tonic-gate 13617c478bd9Sstevel@tonic-gate /* 13627c478bd9Sstevel@tonic-gate * If we're being audited tell the audit library of the file we're about 13637c478bd9Sstevel@tonic-gate * to go search for. The audit library may offer an alternative 13647c478bd9Sstevel@tonic-gate * dependency, or indicate that this dependency should be ignored. 13657c478bd9Sstevel@tonic-gate */ 13667c478bd9Sstevel@tonic-gate if ((lml->lm_tflags | FLAGS1(clmp)) & LML_TFLG_AUD_OBJSEARCH) { 13677c478bd9Sstevel@tonic-gate char *aname = audit_objsearch(clmp, nname, dir->p_orig); 13687c478bd9Sstevel@tonic-gate 13697c478bd9Sstevel@tonic-gate if (aname == 0) 13707c478bd9Sstevel@tonic-gate return (0); 13717c478bd9Sstevel@tonic-gate nname = aname; 13727c478bd9Sstevel@tonic-gate } 13737c478bd9Sstevel@tonic-gate return (file_open(0, lml, oname, nname, clmp, flags, fdesc, rej)); 13747c478bd9Sstevel@tonic-gate } 13757c478bd9Sstevel@tonic-gate 1376390b98b5Srie static int 13777c478bd9Sstevel@tonic-gate find_file(Lm_list *lml, const char *oname, Rt_map *clmp, uint_t flags, 13787c478bd9Sstevel@tonic-gate Fdesc * fdesc, Rej_desc *rej, Pnode * dir, Word * strhash, size_t olen) 13797c478bd9Sstevel@tonic-gate { 13807c478bd9Sstevel@tonic-gate static Rtc_obj Obj = { 0 }; 13817c478bd9Sstevel@tonic-gate Rtc_obj * dobj; 13827c478bd9Sstevel@tonic-gate const char *nname = oname; 13837c478bd9Sstevel@tonic-gate 13847c478bd9Sstevel@tonic-gate if (dir->p_name == 0) 13857c478bd9Sstevel@tonic-gate return (0); 13867c478bd9Sstevel@tonic-gate if (dir->p_info) { 13877c478bd9Sstevel@tonic-gate dobj = (Rtc_obj *)dir->p_info; 13887c478bd9Sstevel@tonic-gate if ((dobj->co_flags & 13897c478bd9Sstevel@tonic-gate (RTC_OBJ_NOEXIST | RTC_OBJ_ALTER)) == RTC_OBJ_NOEXIST) 13907c478bd9Sstevel@tonic-gate return (0); 13917c478bd9Sstevel@tonic-gate } else 13927c478bd9Sstevel@tonic-gate dobj = 0; 13937c478bd9Sstevel@tonic-gate 13947c478bd9Sstevel@tonic-gate /* 13957c478bd9Sstevel@tonic-gate * If configuration information exists see if this directory/file 13967c478bd9Sstevel@tonic-gate * combination exists. 13977c478bd9Sstevel@tonic-gate */ 13987c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_DIRCFG) && 13997c478bd9Sstevel@tonic-gate ((dobj == 0) || (dobj->co_id != 0))) { 14007c478bd9Sstevel@tonic-gate Rtc_obj *fobj; 14017c478bd9Sstevel@tonic-gate const char *alt = 0; 14027c478bd9Sstevel@tonic-gate 14037c478bd9Sstevel@tonic-gate /* 14047c478bd9Sstevel@tonic-gate * If this pnode has not yet been searched for in the 14057c478bd9Sstevel@tonic-gate * configuration file go find it. 14067c478bd9Sstevel@tonic-gate */ 14077c478bd9Sstevel@tonic-gate if (dobj == 0) { 14087c478bd9Sstevel@tonic-gate dobj = elf_config_ent(dir->p_name, 14097c478bd9Sstevel@tonic-gate (Word)elf_hash(dir->p_name), 0, 0); 14107c478bd9Sstevel@tonic-gate if (dobj == 0) 14117c478bd9Sstevel@tonic-gate dobj = &Obj; 14127c478bd9Sstevel@tonic-gate dir->p_info = (void *)dobj; 14137c478bd9Sstevel@tonic-gate 14147c478bd9Sstevel@tonic-gate if ((dobj->co_flags & (RTC_OBJ_NOEXIST | 14157c478bd9Sstevel@tonic-gate RTC_OBJ_ALTER)) == RTC_OBJ_NOEXIST) 14167c478bd9Sstevel@tonic-gate return (0); 14177c478bd9Sstevel@tonic-gate } 14187c478bd9Sstevel@tonic-gate 14197c478bd9Sstevel@tonic-gate /* 14207c478bd9Sstevel@tonic-gate * If we found a directory search for the file. 14217c478bd9Sstevel@tonic-gate */ 14227c478bd9Sstevel@tonic-gate if (dobj->co_id != 0) { 14237c478bd9Sstevel@tonic-gate if (*strhash == 0) 14247c478bd9Sstevel@tonic-gate *strhash = (Word)elf_hash(nname); 14257c478bd9Sstevel@tonic-gate fobj = elf_config_ent(nname, *strhash, 14267c478bd9Sstevel@tonic-gate dobj->co_id, &alt); 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate /* 14297c478bd9Sstevel@tonic-gate * If this object specifically does not exist, or the 14307c478bd9Sstevel@tonic-gate * object can't be found in a know-all-entries 14317c478bd9Sstevel@tonic-gate * directory, continue looking. If the object does 14327c478bd9Sstevel@tonic-gate * exist determine if an alternative object exists. 14337c478bd9Sstevel@tonic-gate */ 14347c478bd9Sstevel@tonic-gate if (fobj == 0) { 14357c478bd9Sstevel@tonic-gate if (dobj->co_flags & RTC_OBJ_ALLENTS) 14367c478bd9Sstevel@tonic-gate return (0); 14377c478bd9Sstevel@tonic-gate } else { 14387c478bd9Sstevel@tonic-gate if ((fobj->co_flags & (RTC_OBJ_NOEXIST | 14397c478bd9Sstevel@tonic-gate RTC_OBJ_ALTER)) == RTC_OBJ_NOEXIST) 14407c478bd9Sstevel@tonic-gate return (0); 14417c478bd9Sstevel@tonic-gate 14427c478bd9Sstevel@tonic-gate if ((fobj->co_flags & RTC_OBJ_ALTER) && 14437c478bd9Sstevel@tonic-gate (rtld_flags & RT_FL_OBJALT) && 14447c478bd9Sstevel@tonic-gate (lml == &lml_main)) { 14457c478bd9Sstevel@tonic-gate int ret; 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate fdesc->fd_flags |= FLG_FD_ALTER; 14487c478bd9Sstevel@tonic-gate /* 14497c478bd9Sstevel@tonic-gate * Attempt to open the alternative path. 14507c478bd9Sstevel@tonic-gate * If this fails, and the alternative is 14517c478bd9Sstevel@tonic-gate * flagged as optional, fall through to 14527c478bd9Sstevel@tonic-gate * open the original path. 14537c478bd9Sstevel@tonic-gate */ 14547c478bd9Sstevel@tonic-gate ret = _find_file(lml, oname, alt, clmp, 14557c478bd9Sstevel@tonic-gate flags, fdesc, rej, dir, 1); 14567c478bd9Sstevel@tonic-gate if (ret || ((fobj->co_flags & 14577c478bd9Sstevel@tonic-gate RTC_OBJ_OPTINAL) == 0)) 14587c478bd9Sstevel@tonic-gate return (ret); 14597c478bd9Sstevel@tonic-gate 14607c478bd9Sstevel@tonic-gate fdesc->fd_flags &= ~FLG_FD_ALTER; 14617c478bd9Sstevel@tonic-gate } 14627c478bd9Sstevel@tonic-gate } 14637c478bd9Sstevel@tonic-gate } 14647c478bd9Sstevel@tonic-gate } 14657c478bd9Sstevel@tonic-gate 14667c478bd9Sstevel@tonic-gate /* 14677c478bd9Sstevel@tonic-gate * Protect ourselves from building an invalid pathname. 14687c478bd9Sstevel@tonic-gate */ 14697c478bd9Sstevel@tonic-gate if ((olen + dir->p_len + 1) >= PATH_MAX) { 1470*5aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), nname, 14717c478bd9Sstevel@tonic-gate strerror(ENAMETOOLONG)); 14727c478bd9Sstevel@tonic-gate return (0); 14737c478bd9Sstevel@tonic-gate } 14747c478bd9Sstevel@tonic-gate if ((nname = (LM_GET_SO(clmp)(dir->p_name, nname))) == 0) 14757c478bd9Sstevel@tonic-gate return (0); 14767c478bd9Sstevel@tonic-gate 14777c478bd9Sstevel@tonic-gate return (_find_file(lml, oname, nname, clmp, flags, fdesc, rej, dir, 0)); 14787c478bd9Sstevel@tonic-gate } 14797c478bd9Sstevel@tonic-gate 14807c478bd9Sstevel@tonic-gate /* 14817c478bd9Sstevel@tonic-gate * A unique file has been opened. Create a link-map to represent it, and 14827c478bd9Sstevel@tonic-gate * process the various names by which it can be referenced. 14837c478bd9Sstevel@tonic-gate */ 14847c478bd9Sstevel@tonic-gate static Rt_map * 1485390b98b5Srie load_file(Lm_list *lml, Aliste lmco, Fdesc *fdesc) 14867c478bd9Sstevel@tonic-gate { 14877c478bd9Sstevel@tonic-gate const char *oname = fdesc->fd_oname; 14887c478bd9Sstevel@tonic-gate const char *nname = fdesc->fd_nname; 14897c478bd9Sstevel@tonic-gate Rt_map *nlmp; 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate /* 14927c478bd9Sstevel@tonic-gate * Typically we call fct_map_so() with the full pathname of the opened 14937c478bd9Sstevel@tonic-gate * file (nname) and the name that started the search (oname), thus for 14947c478bd9Sstevel@tonic-gate * a typical dependency on libc this would be /usr/lib/libc.so.1 and 14957c478bd9Sstevel@tonic-gate * libc.so.1 (DT_NEEDED). The original name is maintained on an ALIAS 14967c478bd9Sstevel@tonic-gate * list for comparison when bringing in new dependencies. If the user 14977c478bd9Sstevel@tonic-gate * specified name as a full path (from a dlopen() for example) then 14987c478bd9Sstevel@tonic-gate * there's no need to create an ALIAS. 14997c478bd9Sstevel@tonic-gate */ 15007c478bd9Sstevel@tonic-gate if (strcmp(oname, nname) == 0) 15017c478bd9Sstevel@tonic-gate oname = 0; 15027c478bd9Sstevel@tonic-gate 15037c478bd9Sstevel@tonic-gate /* 15047c478bd9Sstevel@tonic-gate * A new file has been opened, now map it into the process. Close the 15057c478bd9Sstevel@tonic-gate * original file so as not to accumulate file descriptors. 15067c478bd9Sstevel@tonic-gate */ 15077c478bd9Sstevel@tonic-gate nlmp = ((fdesc->fd_ftp)->fct_map_so)(lml, lmco, nname, oname, 15087c478bd9Sstevel@tonic-gate fdesc->fd_fd); 15097c478bd9Sstevel@tonic-gate (void) close(fdesc->fd_fd); 15107c478bd9Sstevel@tonic-gate fdesc->fd_fd = 0; 15117c478bd9Sstevel@tonic-gate 15127c478bd9Sstevel@tonic-gate if (nlmp == 0) 15137c478bd9Sstevel@tonic-gate return (0); 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate /* 15167c478bd9Sstevel@tonic-gate * Save the dev/inode information for later comparisons. 15177c478bd9Sstevel@tonic-gate */ 15187c478bd9Sstevel@tonic-gate STDEV(nlmp) = fdesc->fd_dev; 15197c478bd9Sstevel@tonic-gate STINO(nlmp) = fdesc->fd_ino; 15207c478bd9Sstevel@tonic-gate 15217c478bd9Sstevel@tonic-gate /* 15227c478bd9Sstevel@tonic-gate * Insert the names of this link-map into the FullpathNode AVL tree. 15237c478bd9Sstevel@tonic-gate * Save both the NAME() and PATHNAME() is they differ. 15247c478bd9Sstevel@tonic-gate * 15257c478bd9Sstevel@tonic-gate * If this is an OBJECT file, don't insert it yet as this is only a 15267c478bd9Sstevel@tonic-gate * temporary link-map. During elf_obj_fini() the final link-map is 15277c478bd9Sstevel@tonic-gate * created, and its names will be inserted in the FullpathNode AVL 15287c478bd9Sstevel@tonic-gate * tree at that time. 15297c478bd9Sstevel@tonic-gate */ 15307c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) & FLG_RT_OBJECT) == 0) { 15317c478bd9Sstevel@tonic-gate /* 15327c478bd9Sstevel@tonic-gate * Update the objects full path information if necessary. 153311a2bb38Srie * Note, with pathname expansion in effect, the fd_pname will 153411a2bb38Srie * be used as PATHNAME(). This allocated string will be freed 153511a2bb38Srie * should this object be deleted. However, without pathname 153611a2bb38Srie * expansion, the fd_name should be freed now, as it is no 153711a2bb38Srie * longer referenced. 15387c478bd9Sstevel@tonic-gate */ 153911a2bb38Srie if (FLAGS1(nlmp) & FL1_RT_RELATIVE) 15407c478bd9Sstevel@tonic-gate (void) fullpath(nlmp, fdesc->fd_pname); 154111a2bb38Srie else if (fdesc->fd_pname != fdesc->fd_nname) 154211a2bb38Srie free((void *)fdesc->fd_pname); 15437c478bd9Sstevel@tonic-gate fdesc->fd_pname = 0; 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate if ((NAME(nlmp)[0] == '/') && (fpavl_insert(lml, nlmp, 15467c478bd9Sstevel@tonic-gate NAME(nlmp), fdesc->fd_avlwhere) == 0)) { 15477c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 15487c478bd9Sstevel@tonic-gate return (0); 15497c478bd9Sstevel@tonic-gate } 15507c478bd9Sstevel@tonic-gate if (((NAME(nlmp)[0] != '/') || 15517c478bd9Sstevel@tonic-gate (NAME(nlmp) != PATHNAME(nlmp))) && 15527c478bd9Sstevel@tonic-gate (fpavl_insert(lml, nlmp, PATHNAME(nlmp), 0) == 0)) { 15537c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 15547c478bd9Sstevel@tonic-gate return (0); 15557c478bd9Sstevel@tonic-gate } 15567c478bd9Sstevel@tonic-gate } 15577c478bd9Sstevel@tonic-gate 15587c478bd9Sstevel@tonic-gate /* 15597c478bd9Sstevel@tonic-gate * If we're processing an alternative object reset the original name 15607c478bd9Sstevel@tonic-gate * for possible $ORIGIN processing. 15617c478bd9Sstevel@tonic-gate */ 15627c478bd9Sstevel@tonic-gate if (fdesc->fd_flags & FLG_FD_ALTER) { 15637c478bd9Sstevel@tonic-gate const char *odir; 15647c478bd9Sstevel@tonic-gate char *ndir; 15657c478bd9Sstevel@tonic-gate size_t olen; 15667c478bd9Sstevel@tonic-gate 15677c478bd9Sstevel@tonic-gate FLAGS(nlmp) |= FLG_RT_ALTER; 15687c478bd9Sstevel@tonic-gate 15697c478bd9Sstevel@tonic-gate /* 15707c478bd9Sstevel@tonic-gate * If we were given a pathname containing a slash then the 15717c478bd9Sstevel@tonic-gate * original name is still in oname. Otherwise the original 15727c478bd9Sstevel@tonic-gate * directory is in dir->p_name (which is all we need for 15737c478bd9Sstevel@tonic-gate * $ORIGIN). 15747c478bd9Sstevel@tonic-gate */ 15757c478bd9Sstevel@tonic-gate if (fdesc->fd_flags & FLG_FD_SLASH) { 15767c478bd9Sstevel@tonic-gate char *ofil; 15777c478bd9Sstevel@tonic-gate 15787c478bd9Sstevel@tonic-gate odir = oname; 15797c478bd9Sstevel@tonic-gate ofil = strrchr(oname, '/'); 15807c478bd9Sstevel@tonic-gate olen = ofil - odir + 1; 15817c478bd9Sstevel@tonic-gate } else { 15827c478bd9Sstevel@tonic-gate odir = fdesc->fd_odir; 15837c478bd9Sstevel@tonic-gate olen = strlen(odir) + 1; 15847c478bd9Sstevel@tonic-gate } 15857c478bd9Sstevel@tonic-gate 15867c478bd9Sstevel@tonic-gate if ((ndir = (char *)malloc(olen)) == 0) { 15877c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 15887c478bd9Sstevel@tonic-gate return (0); 15897c478bd9Sstevel@tonic-gate } 15907c478bd9Sstevel@tonic-gate (void) strncpy(ndir, odir, olen); 15917c478bd9Sstevel@tonic-gate ndir[--olen] = '\0'; 15927c478bd9Sstevel@tonic-gate 15937c478bd9Sstevel@tonic-gate ORIGNAME(nlmp) = ndir; 15947c478bd9Sstevel@tonic-gate DIRSZ(nlmp) = olen; 15957c478bd9Sstevel@tonic-gate } 15967c478bd9Sstevel@tonic-gate 15977c478bd9Sstevel@tonic-gate /* 1598390b98b5Srie * Identify this as a new object. 15997c478bd9Sstevel@tonic-gate */ 1600390b98b5Srie FLAGS(nlmp) |= FLG_RT_NEWLOAD; 16017c478bd9Sstevel@tonic-gate 16027c478bd9Sstevel@tonic-gate /* 16037c478bd9Sstevel@tonic-gate * Report module loads to TLS module activity. 16047c478bd9Sstevel@tonic-gate */ 16057c478bd9Sstevel@tonic-gate if (nlmp) 16067c478bd9Sstevel@tonic-gate tls_modactivity(nlmp, TM_FLG_MODADD); 16077c478bd9Sstevel@tonic-gate 16087c478bd9Sstevel@tonic-gate return (nlmp); 16097c478bd9Sstevel@tonic-gate } 16107c478bd9Sstevel@tonic-gate 16117c478bd9Sstevel@tonic-gate /* 16127c478bd9Sstevel@tonic-gate * This function loads the named file and returns a pointer to its link map. 16137c478bd9Sstevel@tonic-gate * It is assumed that the caller has already checked that the file is not 16147c478bd9Sstevel@tonic-gate * already loaded before calling this function (refer is_so_loaded()). 16157c478bd9Sstevel@tonic-gate * Find and open the file, map it into memory, add it to the end of the list 16167c478bd9Sstevel@tonic-gate * of link maps and return a pointer to the new link map. Return 0 on error. 16177c478bd9Sstevel@tonic-gate */ 16187c478bd9Sstevel@tonic-gate static Rt_map * 16197c478bd9Sstevel@tonic-gate load_so(Lm_list *lml, Aliste lmco, const char *oname, Rt_map *clmp, 1620fb1354edSrie uint_t flags, Fdesc *nfdp, Rej_desc *rej) 16217c478bd9Sstevel@tonic-gate { 16227c478bd9Sstevel@tonic-gate char *name; 16237c478bd9Sstevel@tonic-gate uint_t slash = 0; 16247c478bd9Sstevel@tonic-gate size_t olen; 1625fb1354edSrie Fdesc fdesc = { 0 }; 16267c478bd9Sstevel@tonic-gate Pnode *dir; 16277c478bd9Sstevel@tonic-gate 16287c478bd9Sstevel@tonic-gate /* 16297c478bd9Sstevel@tonic-gate * If the file is the run time linker then it's already loaded. 16307c478bd9Sstevel@tonic-gate */ 16317c478bd9Sstevel@tonic-gate if (interp && (strcmp(oname, NAME(lml_rtld.lm_head)) == 0)) 16327c478bd9Sstevel@tonic-gate return (lml_rtld.lm_head); 16337c478bd9Sstevel@tonic-gate 16347c478bd9Sstevel@tonic-gate /* 16357c478bd9Sstevel@tonic-gate * If this isn't a hardware capabilites pathname, which is already a 16367c478bd9Sstevel@tonic-gate * full, duplicated pathname, determine whether the pathname contains 16377c478bd9Sstevel@tonic-gate * a slash, and if not determine the input filename (for max path 16387c478bd9Sstevel@tonic-gate * length verification). 16397c478bd9Sstevel@tonic-gate */ 16407c478bd9Sstevel@tonic-gate if ((flags & FLG_RT_HWCAP) == 0) { 16417c478bd9Sstevel@tonic-gate const char *str; 16427c478bd9Sstevel@tonic-gate 16437c478bd9Sstevel@tonic-gate for (str = oname; *str; str++) { 16447c478bd9Sstevel@tonic-gate if (*str == '/') { 16457c478bd9Sstevel@tonic-gate slash++; 16467c478bd9Sstevel@tonic-gate break; 16477c478bd9Sstevel@tonic-gate } 16487c478bd9Sstevel@tonic-gate } 16497c478bd9Sstevel@tonic-gate if (slash == 0) 16507c478bd9Sstevel@tonic-gate olen = (str - oname) + 1; 16517c478bd9Sstevel@tonic-gate } 16527c478bd9Sstevel@tonic-gate 16537c478bd9Sstevel@tonic-gate /* 16547c478bd9Sstevel@tonic-gate * If we are passed a 'null' link-map this means that this is the first 16557c478bd9Sstevel@tonic-gate * object to be loaded on this link-map list. In that case we set the 16567c478bd9Sstevel@tonic-gate * link-map to ld.so.1's link-map. 16577c478bd9Sstevel@tonic-gate * 16587c478bd9Sstevel@tonic-gate * This link-map is referenced to determine what lookup rules to use 16597c478bd9Sstevel@tonic-gate * when searching for files. By using ld.so.1's we are defaulting to 16607c478bd9Sstevel@tonic-gate * ELF look-up rules. 16617c478bd9Sstevel@tonic-gate * 16627c478bd9Sstevel@tonic-gate * Note: This case happens when loading the first object onto 16637c478bd9Sstevel@tonic-gate * the plt_tracing link-map. 16647c478bd9Sstevel@tonic-gate */ 16657c478bd9Sstevel@tonic-gate if (clmp == 0) 16667c478bd9Sstevel@tonic-gate clmp = lml_rtld.lm_head; 16677c478bd9Sstevel@tonic-gate 16687c478bd9Sstevel@tonic-gate /* 16697c478bd9Sstevel@tonic-gate * If this path resulted from a $HWCAP specification, then the best 16707c478bd9Sstevel@tonic-gate * hardware capability object has already been establish, and is 16717c478bd9Sstevel@tonic-gate * available in the calling file descriptor. Perform some minor book- 16727c478bd9Sstevel@tonic-gate * keeping so that we can fall through into common code. 16737c478bd9Sstevel@tonic-gate */ 16747c478bd9Sstevel@tonic-gate if (flags & FLG_RT_HWCAP) { 16757c478bd9Sstevel@tonic-gate /* 1676fb1354edSrie * If this object is already loaded, we're done. 16777c478bd9Sstevel@tonic-gate */ 1678fb1354edSrie if (nfdp->fd_lmp) 1679fb1354edSrie return (nfdp->fd_lmp); 16807c478bd9Sstevel@tonic-gate 16817c478bd9Sstevel@tonic-gate /* 16827c478bd9Sstevel@tonic-gate * Obtain the avl index for this object. 16837c478bd9Sstevel@tonic-gate */ 1684fb1354edSrie (void) fpavl_loaded(lml, nfdp->fd_nname, &(nfdp->fd_avlwhere)); 1685bbf522bdSrie 1686bbf522bdSrie /* 1687fb1354edSrie * If the name and resolved pathname differ, duplicate the path 1688fb1354edSrie * name once more to provide for genric cleanup by the caller. 1689bbf522bdSrie */ 1690fb1354edSrie if (nfdp->fd_pname && (nfdp->fd_nname != nfdp->fd_pname)) { 1691bbf522bdSrie char *pname; 1692bbf522bdSrie 1693fb1354edSrie if ((pname = strdup(nfdp->fd_pname)) == 0) 1694bbf522bdSrie return (0); 1695fb1354edSrie nfdp->fd_pname = pname; 1696bbf522bdSrie } 16977c478bd9Sstevel@tonic-gate } else if (slash) { 16987c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 16997c478bd9Sstevel@tonic-gate 1700fb1354edSrie *nfdp = fdesc; 1701fb1354edSrie nfdp->fd_flags = FLG_FD_SLASH; 17027c478bd9Sstevel@tonic-gate 1703fb1354edSrie if (find_path(lml, oname, clmp, flags, nfdp, &_rej) == 0) { 1704fb1354edSrie rejection_inherit(rej, &_rej, nfdp); 17057c478bd9Sstevel@tonic-gate return (0); 17067c478bd9Sstevel@tonic-gate } 17077c478bd9Sstevel@tonic-gate 17087c478bd9Sstevel@tonic-gate /* 17097c478bd9Sstevel@tonic-gate * If this object is already loaded, we're done. 17107c478bd9Sstevel@tonic-gate */ 1711fb1354edSrie if (nfdp->fd_lmp) 1712fb1354edSrie return (nfdp->fd_lmp); 17137c478bd9Sstevel@tonic-gate 17147c478bd9Sstevel@tonic-gate } else { 17157c478bd9Sstevel@tonic-gate /* 17167c478bd9Sstevel@tonic-gate * No '/' - for each directory on list, make a pathname using 17177c478bd9Sstevel@tonic-gate * that directory and filename and try to open that file. 17187c478bd9Sstevel@tonic-gate */ 17197c478bd9Sstevel@tonic-gate Pnode *dirlist = (Pnode *)0; 17207c478bd9Sstevel@tonic-gate Word strhash = 0; 1721fb1354edSrie #if !defined(ISSOLOAD_BASENAME_DISABLED) 1722fb1354edSrie Rt_map *nlmp; 1723fb1354edSrie #endif 1724*5aefb655Srie DBG_CALL(Dbg_libs_find(lml, oname)); 17257c478bd9Sstevel@tonic-gate 17267c478bd9Sstevel@tonic-gate #if !defined(ISSOLOAD_BASENAME_DISABLED) 17277c478bd9Sstevel@tonic-gate if ((nlmp = is_so_loaded(lml, oname, 0))) 17287c478bd9Sstevel@tonic-gate return (nlmp); 17297c478bd9Sstevel@tonic-gate #endif 17307c478bd9Sstevel@tonic-gate /* 17317c478bd9Sstevel@tonic-gate * Make sure we clear the file descriptor new name in case the 17327c478bd9Sstevel@tonic-gate * following directory search doesn't provide any directories 17337c478bd9Sstevel@tonic-gate * (odd, but this can be forced with a -znodefaultlib test). 17347c478bd9Sstevel@tonic-gate */ 1735fb1354edSrie *nfdp = fdesc; 17367c478bd9Sstevel@tonic-gate for (dir = get_next_dir(&dirlist, clmp, flags); dir; 17377c478bd9Sstevel@tonic-gate dir = get_next_dir(&dirlist, clmp, flags)) { 17387c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 17397c478bd9Sstevel@tonic-gate 1740fb1354edSrie *nfdp = fdesc; 17417c478bd9Sstevel@tonic-gate 17427c478bd9Sstevel@tonic-gate /* 17437c478bd9Sstevel@tonic-gate * Try and locate this file. Make sure to clean up 17447c478bd9Sstevel@tonic-gate * any rejection information should the file have 17457c478bd9Sstevel@tonic-gate * been found, but not appropriate. 17467c478bd9Sstevel@tonic-gate */ 1747fb1354edSrie if (find_file(lml, oname, clmp, flags, nfdp, &_rej, 17487c478bd9Sstevel@tonic-gate dir, &strhash, olen) == 0) { 1749fb1354edSrie rejection_inherit(rej, &_rej, nfdp); 17507c478bd9Sstevel@tonic-gate continue; 17517c478bd9Sstevel@tonic-gate } 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate /* 17547c478bd9Sstevel@tonic-gate * If this object is already loaded, we're done. 17557c478bd9Sstevel@tonic-gate */ 1756fb1354edSrie if (nfdp->fd_lmp) 1757fb1354edSrie return (nfdp->fd_lmp); 17587c478bd9Sstevel@tonic-gate 1759fb1354edSrie nfdp->fd_odir = dir->p_name; 17607c478bd9Sstevel@tonic-gate break; 17617c478bd9Sstevel@tonic-gate } 17627c478bd9Sstevel@tonic-gate 17637c478bd9Sstevel@tonic-gate /* 17647c478bd9Sstevel@tonic-gate * If the file couldn't be loaded, do another comparison of 17657c478bd9Sstevel@tonic-gate * loaded files using just the basename. This catches folks 17667c478bd9Sstevel@tonic-gate * who may have loaded multiple full pathname files (possibly 17677c478bd9Sstevel@tonic-gate * from setxid applications) to satisfy dependency relationships 17687c478bd9Sstevel@tonic-gate * (i.e., a file might have a dependency on foo.so.1 which has 17697c478bd9Sstevel@tonic-gate * already been opened using its full pathname). 17707c478bd9Sstevel@tonic-gate */ 1771fb1354edSrie if (nfdp->fd_nname == 0) 17727c478bd9Sstevel@tonic-gate return (is_so_loaded(lml, oname, 1)); 17737c478bd9Sstevel@tonic-gate } 17747c478bd9Sstevel@tonic-gate 17757c478bd9Sstevel@tonic-gate /* 17767c478bd9Sstevel@tonic-gate * Duplicate the file name so that NAME() is available in core files. 17777c478bd9Sstevel@tonic-gate * Note, that hardware capability names are already duplicated, but 17787c478bd9Sstevel@tonic-gate * they get duplicated once more to insure consistent cleanup in the 17797c478bd9Sstevel@tonic-gate * event of an error condition. 17807c478bd9Sstevel@tonic-gate */ 1781fb1354edSrie if ((name = strdup(nfdp->fd_nname)) == 0) 17827c478bd9Sstevel@tonic-gate return (0); 1783fb1354edSrie 1784fb1354edSrie if (nfdp->fd_nname == nfdp->fd_pname) 1785fb1354edSrie nfdp->fd_nname = nfdp->fd_pname = name; 17867c478bd9Sstevel@tonic-gate else 1787fb1354edSrie nfdp->fd_nname = name; 17887c478bd9Sstevel@tonic-gate 17897c478bd9Sstevel@tonic-gate /* 17907c478bd9Sstevel@tonic-gate * Finish mapping the file and return the link-map descriptor. Note, 17917c478bd9Sstevel@tonic-gate * if this request originated from a HWCAP request, re-establish the 17927c478bd9Sstevel@tonic-gate * fdesc information. For single paged objects, such as filters, the 17937c478bd9Sstevel@tonic-gate * original mapping may have been sufficient to capture the file, thus 17947c478bd9Sstevel@tonic-gate * this mapping needs to be reset to insure it doesn't mistakenly get 17957c478bd9Sstevel@tonic-gate * unmapped as part of HWCAP cleanup. 17967c478bd9Sstevel@tonic-gate */ 1797fb1354edSrie return (load_file(lml, lmco, nfdp)); 17987c478bd9Sstevel@tonic-gate } 17997c478bd9Sstevel@tonic-gate 18007c478bd9Sstevel@tonic-gate /* 18017c478bd9Sstevel@tonic-gate * Trace an attempt to load an object. 18027c478bd9Sstevel@tonic-gate */ 18037c478bd9Sstevel@tonic-gate const char * 18047c478bd9Sstevel@tonic-gate load_trace(Lm_list *lml, const char *name, Rt_map *clmp) 18057c478bd9Sstevel@tonic-gate { 18067c478bd9Sstevel@tonic-gate /* 18077c478bd9Sstevel@tonic-gate * First generate any ldd(1) diagnostics. 18087c478bd9Sstevel@tonic-gate */ 18097c478bd9Sstevel@tonic-gate if ((lml->lm_flags & (LML_FLG_TRC_VERBOSE | LML_FLG_TRC_SEARCH)) && 18107c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) 18117c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_FIL_FIND), name, NAME(clmp)); 18127c478bd9Sstevel@tonic-gate 18137c478bd9Sstevel@tonic-gate /* 18147c478bd9Sstevel@tonic-gate * If we're being audited tell the audit library of the file we're 18157c478bd9Sstevel@tonic-gate * about to go search for. 18167c478bd9Sstevel@tonic-gate */ 18177c478bd9Sstevel@tonic-gate if (((lml->lm_tflags | FLAGS1(clmp)) & LML_TFLG_AUD_ACTIVITY) && 18187c478bd9Sstevel@tonic-gate (lml == LIST(clmp))) 18197c478bd9Sstevel@tonic-gate audit_activity(clmp, LA_ACT_ADD); 18207c478bd9Sstevel@tonic-gate 18217c478bd9Sstevel@tonic-gate if ((lml->lm_tflags | FLAGS1(clmp)) & LML_TFLG_AUD_OBJSEARCH) { 18227c478bd9Sstevel@tonic-gate char *_name; 18237c478bd9Sstevel@tonic-gate 18247c478bd9Sstevel@tonic-gate /* 18257c478bd9Sstevel@tonic-gate * The auditor can indicate that this object should be ignored. 18267c478bd9Sstevel@tonic-gate */ 18277c478bd9Sstevel@tonic-gate if ((_name = audit_objsearch(clmp, name, LA_SER_ORIG)) == 0) { 1828*5aefb655Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_GEN_AUDITERM), 1829*5aefb655Srie name); 18307c478bd9Sstevel@tonic-gate return (0); 18317c478bd9Sstevel@tonic-gate } 18327c478bd9Sstevel@tonic-gate 18337c478bd9Sstevel@tonic-gate /* 18347c478bd9Sstevel@tonic-gate * The auditor can provide an alternative name. 18357c478bd9Sstevel@tonic-gate */ 18367c478bd9Sstevel@tonic-gate if (_name != name) { 18377c478bd9Sstevel@tonic-gate free((void *)name); 18387c478bd9Sstevel@tonic-gate name = strdup(_name); 18397c478bd9Sstevel@tonic-gate } 18407c478bd9Sstevel@tonic-gate } 18417c478bd9Sstevel@tonic-gate return (name); 18427c478bd9Sstevel@tonic-gate } 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate /* 18457c478bd9Sstevel@tonic-gate * Having loaded an object and created a link-map to describe it, finish 18467c478bd9Sstevel@tonic-gate * processing this stage, including verifying any versioning requirements, 18477c478bd9Sstevel@tonic-gate * updating the objects mode, creating a handle if necessary, and adding this 18487c478bd9Sstevel@tonic-gate * object to existing handles if required. 18497c478bd9Sstevel@tonic-gate */ 1850390b98b5Srie static int 18517c478bd9Sstevel@tonic-gate load_finish(Lm_list *lml, const char *name, Rt_map *clmp, int nmode, 18527c478bd9Sstevel@tonic-gate uint_t flags, Grp_hdl **hdl, Rt_map *nlmp) 18537c478bd9Sstevel@tonic-gate { 18547c478bd9Sstevel@tonic-gate Aliste off; 18557c478bd9Sstevel@tonic-gate Grp_hdl *ghp, **ghpp; 18567c478bd9Sstevel@tonic-gate int promote; 18577c478bd9Sstevel@tonic-gate 18587c478bd9Sstevel@tonic-gate /* 18597c478bd9Sstevel@tonic-gate * If this dependency is associated with a required version insure that 18607c478bd9Sstevel@tonic-gate * the version is present in the loaded file. 18617c478bd9Sstevel@tonic-gate */ 18627c478bd9Sstevel@tonic-gate if (((rtld_flags & RT_FL_NOVERSION) == 0) && 18637c478bd9Sstevel@tonic-gate (FCT(clmp) == &elf_fct) && VERNEED(clmp) && 18647c478bd9Sstevel@tonic-gate (LM_VERIFY_VERS(clmp)(name, clmp, nlmp) == 0)) 18657c478bd9Sstevel@tonic-gate return (0); 18667c478bd9Sstevel@tonic-gate 18677c478bd9Sstevel@tonic-gate /* 18687c478bd9Sstevel@tonic-gate * If this object has indicated that it should be isolated as a group 18697c478bd9Sstevel@tonic-gate * (DT_FLAGS_1 contains DF_1_GROUP - object was built with -B group), 18707c478bd9Sstevel@tonic-gate * or if the callers direct bindings indicate it should be isolated as 18717c478bd9Sstevel@tonic-gate * a group (DYNINFO flags contains FLG_DI_GROUP - dependency followed 18727c478bd9Sstevel@tonic-gate * -zgroupperm), establish the appropriate mode. 18737c478bd9Sstevel@tonic-gate * 18747c478bd9Sstevel@tonic-gate * The intent of an object defining itself as a group is to isolate the 18757c478bd9Sstevel@tonic-gate * relocation of the group within its own members, however, unless 18767c478bd9Sstevel@tonic-gate * opened through dlopen(), in which case we assume dlsym() will be used 18777c478bd9Sstevel@tonic-gate * to located symbols in the new object, we still need to associate it 18787c478bd9Sstevel@tonic-gate * with the caller for it to be bound with. This is equivalent to a 18797c478bd9Sstevel@tonic-gate * dlopen(RTLD_GROUP) and dlsym() using the returned handle. 18807c478bd9Sstevel@tonic-gate */ 18817c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) | flags) & FLG_RT_SETGROUP) { 18827c478bd9Sstevel@tonic-gate nmode &= ~RTLD_WORLD; 18837c478bd9Sstevel@tonic-gate nmode |= RTLD_GROUP; 18847c478bd9Sstevel@tonic-gate 18857c478bd9Sstevel@tonic-gate /* 18867c478bd9Sstevel@tonic-gate * If the object wasn't explicitly dlopen()'ed associate it with 18877c478bd9Sstevel@tonic-gate * the parent. 18887c478bd9Sstevel@tonic-gate */ 18897c478bd9Sstevel@tonic-gate if (flags != FLG_RT_HANDLE) 18907c478bd9Sstevel@tonic-gate nmode |= RTLD_PARENT; 18917c478bd9Sstevel@tonic-gate } 18927c478bd9Sstevel@tonic-gate 18937c478bd9Sstevel@tonic-gate /* 18947c478bd9Sstevel@tonic-gate * Establish new mode and flags. 18957c478bd9Sstevel@tonic-gate * 18967c478bd9Sstevel@tonic-gate * For patch backward compatibility, the following use of update_mode() 18977c478bd9Sstevel@tonic-gate * is disabled. 18987c478bd9Sstevel@tonic-gate */ 18997c478bd9Sstevel@tonic-gate #ifdef SIEBEL_DISABLE 19007c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_DISFIX_1) 19017c478bd9Sstevel@tonic-gate promote = MODE(nlmp) |= 19027c478bd9Sstevel@tonic-gate (nmode & ~(RTLD_PARENT | RTLD_NOLOAD | RTLD_FIRST)); 19037c478bd9Sstevel@tonic-gate else 19047c478bd9Sstevel@tonic-gate #endif 19057c478bd9Sstevel@tonic-gate promote = update_mode(nlmp, MODE(nlmp), nmode); 19067c478bd9Sstevel@tonic-gate 19077c478bd9Sstevel@tonic-gate FLAGS(nlmp) |= flags; 19087c478bd9Sstevel@tonic-gate 19097c478bd9Sstevel@tonic-gate /* 19107c478bd9Sstevel@tonic-gate * If we've been asked to establish a handle create one for this object. 19117c478bd9Sstevel@tonic-gate * Or, if this object has already been analyzed, but this reference 19127c478bd9Sstevel@tonic-gate * requires that the mode of the object be promoted, also create a 19137c478bd9Sstevel@tonic-gate * handle to propagate the new modes to all this objects dependencies. 19147c478bd9Sstevel@tonic-gate */ 19157c478bd9Sstevel@tonic-gate if (((FLAGS(nlmp) | flags) & FLG_RT_HANDLE) || (promote && 19167c478bd9Sstevel@tonic-gate (FLAGS(nlmp) & FLG_RT_ANALYZED))) { 19177c478bd9Sstevel@tonic-gate uint_t oflags, hflags = 0; 19187c478bd9Sstevel@tonic-gate 19197c478bd9Sstevel@tonic-gate if (nmode & RTLD_PARENT) 19207c478bd9Sstevel@tonic-gate hflags |= GPH_PARENT; 19217c478bd9Sstevel@tonic-gate if (nmode & RTLD_FIRST) 19227c478bd9Sstevel@tonic-gate hflags |= GPH_FIRST; 19237c478bd9Sstevel@tonic-gate 19247c478bd9Sstevel@tonic-gate /* 19257c478bd9Sstevel@tonic-gate * Now that a handle is being created, remove this state from 19267c478bd9Sstevel@tonic-gate * the object so that it doesn't mistakenly get inherited by 19277c478bd9Sstevel@tonic-gate * a dependency. 19287c478bd9Sstevel@tonic-gate */ 19297c478bd9Sstevel@tonic-gate oflags = FLAGS(nlmp); 19307c478bd9Sstevel@tonic-gate FLAGS(nlmp) &= ~FLG_RT_HANDLE; 19317c478bd9Sstevel@tonic-gate 19327c478bd9Sstevel@tonic-gate if ((ghp = hdl_create(lml, nlmp, clmp, hflags)) == 0) 19337c478bd9Sstevel@tonic-gate return (0); 19347c478bd9Sstevel@tonic-gate 19357c478bd9Sstevel@tonic-gate /* 19367c478bd9Sstevel@tonic-gate * Add any dependencies that are already loaded, to the handle. 19377c478bd9Sstevel@tonic-gate */ 19387c478bd9Sstevel@tonic-gate if (hdl_initialize(ghp, nlmp, clmp, nmode, promote) == 0) 19397c478bd9Sstevel@tonic-gate return (0); 19407c478bd9Sstevel@tonic-gate 19417c478bd9Sstevel@tonic-gate if (hdl) 19427c478bd9Sstevel@tonic-gate *hdl = ghp; 19437c478bd9Sstevel@tonic-gate 19447c478bd9Sstevel@tonic-gate /* 19457c478bd9Sstevel@tonic-gate * If we were asked to create a handle, we're done. Otherwise, 19467c478bd9Sstevel@tonic-gate * remove the handle. The handle was only used to establish this 19477c478bd9Sstevel@tonic-gate * objects dependencies and promote any modes, so we don't want 19487c478bd9Sstevel@tonic-gate * this handle preventing the objects deletion. Fall through to 19497c478bd9Sstevel@tonic-gate * carry out any group processing. 19507c478bd9Sstevel@tonic-gate */ 19517c478bd9Sstevel@tonic-gate if ((oflags | flags) & FLG_RT_HANDLE) 19527c478bd9Sstevel@tonic-gate return (1); 19537c478bd9Sstevel@tonic-gate 19547c478bd9Sstevel@tonic-gate free_hdl(ghp); 19557c478bd9Sstevel@tonic-gate } 19567c478bd9Sstevel@tonic-gate 19577c478bd9Sstevel@tonic-gate /* 19587c478bd9Sstevel@tonic-gate * If the caller isn't part of a group we're done. 19597c478bd9Sstevel@tonic-gate */ 19607c478bd9Sstevel@tonic-gate if (GROUPS(clmp) == 0) 19617c478bd9Sstevel@tonic-gate return (1); 19627c478bd9Sstevel@tonic-gate 19637c478bd9Sstevel@tonic-gate /* 19647c478bd9Sstevel@tonic-gate * Determine if our caller is already associated with a handle, if so 19657c478bd9Sstevel@tonic-gate * we need to add this object to any handles that already exist. 19667c478bd9Sstevel@tonic-gate * Traverse the list of groups our caller is a member of and add this 19677c478bd9Sstevel@tonic-gate * new link-map to those groups. 19687c478bd9Sstevel@tonic-gate */ 19697c478bd9Sstevel@tonic-gate DBG_CALL(Dbg_file_hdl_title(DBG_DEP_ADD)); 19707c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(GROUPS(clmp), off, ghpp)) { 19717c478bd9Sstevel@tonic-gate Aliste off1; 19727c478bd9Sstevel@tonic-gate Grp_desc *gdp; 19737c478bd9Sstevel@tonic-gate int exist; 19747c478bd9Sstevel@tonic-gate Rt_map **lmpp; 19757c478bd9Sstevel@tonic-gate Alist *lmalp = 0; 19767c478bd9Sstevel@tonic-gate 19777c478bd9Sstevel@tonic-gate ghp = *ghpp; 19787c478bd9Sstevel@tonic-gate 19797c478bd9Sstevel@tonic-gate /* 19807c478bd9Sstevel@tonic-gate * If the caller doesn't indicate that its dependencies should 19817c478bd9Sstevel@tonic-gate * be added to a handle, ignore it. This case identifies a 19827c478bd9Sstevel@tonic-gate * parent of a dlopen(RTLD_PARENT) request. 19837c478bd9Sstevel@tonic-gate */ 19847c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(ghp->gh_depends, off1, gdp)) { 19857c478bd9Sstevel@tonic-gate if (gdp->gd_depend == clmp) 19867c478bd9Sstevel@tonic-gate break; 19877c478bd9Sstevel@tonic-gate } 19887c478bd9Sstevel@tonic-gate if ((gdp->gd_flags & GPD_ADDEPS) == 0) 19897c478bd9Sstevel@tonic-gate continue; 19907c478bd9Sstevel@tonic-gate 19917c478bd9Sstevel@tonic-gate if ((exist = hdl_add(ghp, nlmp, 19927c478bd9Sstevel@tonic-gate (GPD_AVAIL | GPD_ADDEPS))) == 0) 19937c478bd9Sstevel@tonic-gate return (0); 19947c478bd9Sstevel@tonic-gate 19957c478bd9Sstevel@tonic-gate /* 19967c478bd9Sstevel@tonic-gate * If this member already exists then its dependencies will 19977c478bd9Sstevel@tonic-gate * have already been processed. 19987c478bd9Sstevel@tonic-gate */ 19997c478bd9Sstevel@tonic-gate if (exist == ALE_EXISTS) 20007c478bd9Sstevel@tonic-gate continue; 20017c478bd9Sstevel@tonic-gate 20027c478bd9Sstevel@tonic-gate /* 20037c478bd9Sstevel@tonic-gate * If the object we've added has just been opened, it will not 20047c478bd9Sstevel@tonic-gate * yet have been processed for its dependencies, these will be 20057c478bd9Sstevel@tonic-gate * added on later calls to load_one(). If it doesn't have any 20067c478bd9Sstevel@tonic-gate * dependencies we're also done. 20077c478bd9Sstevel@tonic-gate */ 20087c478bd9Sstevel@tonic-gate if (((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0) || 20097c478bd9Sstevel@tonic-gate (DEPENDS(nlmp) == 0)) 20107c478bd9Sstevel@tonic-gate continue; 20117c478bd9Sstevel@tonic-gate 20127c478bd9Sstevel@tonic-gate /* 20137c478bd9Sstevel@tonic-gate * Otherwise, this object exists and has dependencies, so add 20147c478bd9Sstevel@tonic-gate * all of its dependencies to the handle were operating on. 20157c478bd9Sstevel@tonic-gate */ 20167c478bd9Sstevel@tonic-gate if (alist_append(&lmalp, &nlmp, sizeof (Rt_map *), 20177c478bd9Sstevel@tonic-gate AL_CNT_DEPCLCT) == 0) 20187c478bd9Sstevel@tonic-gate return (0); 20197c478bd9Sstevel@tonic-gate 20207c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(lmalp, off1, lmpp)) { 20217c478bd9Sstevel@tonic-gate Rt_map * dlmp1 = *lmpp; 20227c478bd9Sstevel@tonic-gate Aliste off2; 20237c478bd9Sstevel@tonic-gate Bnd_desc ** bdpp; 20247c478bd9Sstevel@tonic-gate 20257c478bd9Sstevel@tonic-gate /* 20267c478bd9Sstevel@tonic-gate * Add any dependencies of this dependency to the 20277c478bd9Sstevel@tonic-gate * dynamic dependency list so they can be further 20287c478bd9Sstevel@tonic-gate * processed. 20297c478bd9Sstevel@tonic-gate */ 20307c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(DEPENDS(dlmp1), off2, bdpp)) { 20317c478bd9Sstevel@tonic-gate Bnd_desc * bdp = *bdpp; 20327c478bd9Sstevel@tonic-gate Rt_map * dlmp2 = bdp->b_depend; 20337c478bd9Sstevel@tonic-gate 20347c478bd9Sstevel@tonic-gate if ((bdp->b_flags & BND_NEEDED) == 0) 20357c478bd9Sstevel@tonic-gate continue; 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate if (alist_test(&lmalp, dlmp2, sizeof (Rt_map *), 20387c478bd9Sstevel@tonic-gate AL_CNT_DEPCLCT) == 0) { 20397c478bd9Sstevel@tonic-gate free(lmalp); 20407c478bd9Sstevel@tonic-gate return (0); 20417c478bd9Sstevel@tonic-gate } 20427c478bd9Sstevel@tonic-gate } 20437c478bd9Sstevel@tonic-gate 20447c478bd9Sstevel@tonic-gate if (nlmp == dlmp1) 20457c478bd9Sstevel@tonic-gate continue; 20467c478bd9Sstevel@tonic-gate 20477c478bd9Sstevel@tonic-gate if ((exist = hdl_add(ghp, dlmp1, 20487c478bd9Sstevel@tonic-gate (GPD_AVAIL | GPD_ADDEPS))) != 0) { 20497c478bd9Sstevel@tonic-gate if (exist == ALE_CREATE) 20507c478bd9Sstevel@tonic-gate (void) update_mode(dlmp1, MODE(dlmp1), 20517c478bd9Sstevel@tonic-gate nmode); 20527c478bd9Sstevel@tonic-gate continue; 20537c478bd9Sstevel@tonic-gate } 20547c478bd9Sstevel@tonic-gate free(lmalp); 20557c478bd9Sstevel@tonic-gate return (0); 20567c478bd9Sstevel@tonic-gate } 20577c478bd9Sstevel@tonic-gate free(lmalp); 20587c478bd9Sstevel@tonic-gate } 20597c478bd9Sstevel@tonic-gate return (1); 20607c478bd9Sstevel@tonic-gate } 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate /* 20637c478bd9Sstevel@tonic-gate * The central routine for loading shared objects. Insures ldd() diagnostics, 20647c478bd9Sstevel@tonic-gate * handles and any other related additions are all done in one place. 20657c478bd9Sstevel@tonic-gate */ 2066fb1354edSrie static Rt_map * 2067fb1354edSrie _load_path(Lm_list *lml, Aliste lmco, const char *name, Rt_map *clmp, 2068fb1354edSrie int nmode, uint_t flags, Grp_hdl ** hdl, Fdesc *nfdp, Rej_desc *rej) 20697c478bd9Sstevel@tonic-gate { 20707c478bd9Sstevel@tonic-gate Rt_map *nlmp; 20717c478bd9Sstevel@tonic-gate 20727c478bd9Sstevel@tonic-gate if ((nmode & RTLD_NOLOAD) == 0) { 20737c478bd9Sstevel@tonic-gate /* 20747c478bd9Sstevel@tonic-gate * If this isn't a noload request attempt to load the file. 20757c478bd9Sstevel@tonic-gate */ 20767c478bd9Sstevel@tonic-gate if ((name = load_trace(lml, name, clmp)) == 0) 20777c478bd9Sstevel@tonic-gate return (0); 20787c478bd9Sstevel@tonic-gate 20797c478bd9Sstevel@tonic-gate if ((nlmp = load_so(lml, lmco, name, clmp, flags, 2080fb1354edSrie nfdp, rej)) == 0) 20817c478bd9Sstevel@tonic-gate return (0); 20827c478bd9Sstevel@tonic-gate 20837c478bd9Sstevel@tonic-gate /* 20847c478bd9Sstevel@tonic-gate * If we've loaded a library which identifies itself as not 20857c478bd9Sstevel@tonic-gate * being dlopen()'able catch it here. Let non-dlopen()'able 20867c478bd9Sstevel@tonic-gate * objects through under RTLD_CONFGEN as they're only being 20877c478bd9Sstevel@tonic-gate * mapped to be dldump()'ed. 20887c478bd9Sstevel@tonic-gate */ 20897c478bd9Sstevel@tonic-gate if ((rtld_flags & RT_FL_APPLIC) && ((FLAGS(nlmp) & 20907c478bd9Sstevel@tonic-gate (FLG_RT_NOOPEN | FLG_RT_RELOCED)) == FLG_RT_NOOPEN) && 20917c478bd9Sstevel@tonic-gate ((nmode & RTLD_CONFGEN) == 0)) { 20927c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate _rej.rej_name = name; 20957c478bd9Sstevel@tonic-gate _rej.rej_type = SGS_REJ_STR; 20967c478bd9Sstevel@tonic-gate _rej.rej_str = MSG_INTL(MSG_GEN_NOOPEN); 2097*5aefb655Srie DBG_CALL(Dbg_file_rejected(lml, &_rej)); 2098fb1354edSrie rejection_inherit(rej, &_rej, nfdp); 20997c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 21007c478bd9Sstevel@tonic-gate return (0); 21017c478bd9Sstevel@tonic-gate } 21027c478bd9Sstevel@tonic-gate } else { 21037c478bd9Sstevel@tonic-gate /* 21047c478bd9Sstevel@tonic-gate * If it's a NOLOAD request - check to see if the object 21057c478bd9Sstevel@tonic-gate * has already been loaded. 21067c478bd9Sstevel@tonic-gate */ 21077c478bd9Sstevel@tonic-gate /* LINTED */ 21087c478bd9Sstevel@tonic-gate if ((nlmp = is_so_loaded(lml, name, 0)) || 21097c478bd9Sstevel@tonic-gate (nlmp = is_so_loaded(lml, name, 1))) { 21107c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_TRC_VERBOSE) && 21117c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) { 21127c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_FIL_FIND), name, 21137c478bd9Sstevel@tonic-gate NAME(clmp)); 21147c478bd9Sstevel@tonic-gate if (*name == '/') 21157c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_PATH), 21167c478bd9Sstevel@tonic-gate name, MSG_ORIG(MSG_STR_EMPTY), 21177c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 21187c478bd9Sstevel@tonic-gate else 21197c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_FIL_EQUIV), 21207c478bd9Sstevel@tonic-gate name, NAME(nlmp), 21217c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY), 21227c478bd9Sstevel@tonic-gate MSG_ORIG(MSG_STR_EMPTY)); 21237c478bd9Sstevel@tonic-gate } 21247c478bd9Sstevel@tonic-gate } else { 21257c478bd9Sstevel@tonic-gate Rej_desc _rej = { 0 }; 21267c478bd9Sstevel@tonic-gate 21277c478bd9Sstevel@tonic-gate _rej.rej_name = name; 21287c478bd9Sstevel@tonic-gate _rej.rej_type = SGS_REJ_STR; 21297c478bd9Sstevel@tonic-gate _rej.rej_str = strerror(ENOENT); 2130*5aefb655Srie DBG_CALL(Dbg_file_rejected(lml, &_rej)); 2131fb1354edSrie rejection_inherit(rej, &_rej, nfdp); 21327c478bd9Sstevel@tonic-gate return (0); 21337c478bd9Sstevel@tonic-gate } 21347c478bd9Sstevel@tonic-gate } 21357c478bd9Sstevel@tonic-gate 21367c478bd9Sstevel@tonic-gate /* 21377c478bd9Sstevel@tonic-gate * Finish processing this loaded object. 21387c478bd9Sstevel@tonic-gate */ 2139390b98b5Srie if (load_finish(lml, name, clmp, nmode, flags, hdl, nlmp) == 0) { 2140390b98b5Srie FLAGS(nlmp) &= ~FLG_RT_NEWLOAD; 21417c478bd9Sstevel@tonic-gate 21427c478bd9Sstevel@tonic-gate /* 2143390b98b5Srie * If this object has already been analyzed, then it is in use, 2144390b98b5Srie * so even though this operation has failed, it should not be 2145390b98b5Srie * torn down. 21467c478bd9Sstevel@tonic-gate */ 21477c478bd9Sstevel@tonic-gate if ((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0) 21487c478bd9Sstevel@tonic-gate remove_so(lml, nlmp); 21497c478bd9Sstevel@tonic-gate return (0); 21507c478bd9Sstevel@tonic-gate } 21517c478bd9Sstevel@tonic-gate 21527c478bd9Sstevel@tonic-gate /* 2153390b98b5Srie * If this object is new, and we're being audited, tell the audit 2154390b98b5Srie * library of the file we've just opened. Note, if the new link-map 2155390b98b5Srie * requires local auditing of its dependencies we also register its 2156390b98b5Srie * opening. 2157390b98b5Srie */ 2158390b98b5Srie if (FLAGS(nlmp) & FLG_RT_NEWLOAD) { 2159390b98b5Srie FLAGS(nlmp) &= ~FLG_RT_NEWLOAD; 2160390b98b5Srie 2161390b98b5Srie if (((lml->lm_tflags | FLAGS1(clmp) | FLAGS1(nlmp)) & 2162390b98b5Srie LML_TFLG_AUD_MASK) && (((lml->lm_flags | 2163390b98b5Srie LIST(clmp)->lm_flags) & LML_FLG_NOAUDIT) == 0)) { 2164390b98b5Srie if (audit_objopen(clmp, nlmp) == 0) { 2165390b98b5Srie remove_so(lml, nlmp); 2166390b98b5Srie return (0); 2167390b98b5Srie } 2168390b98b5Srie } 2169390b98b5Srie } 2170390b98b5Srie return (nlmp); 2171390b98b5Srie } 2172390b98b5Srie 2173fb1354edSrie Rt_map * 2174fb1354edSrie load_path(Lm_list *lml, Aliste lmco, const char *name, Rt_map *clmp, 2175fb1354edSrie int nmode, uint_t flags, Grp_hdl **hdl, Fdesc *cfdp, Rej_desc *rej) 2176fb1354edSrie { 2177fb1354edSrie Rt_map *lmp; 2178fb1354edSrie Fdesc nfdp = { 0 }; 2179fb1354edSrie 2180fb1354edSrie /* 2181fb1354edSrie * If this path resulted from a $HWCAP specification, then the best 2182fb1354edSrie * hardware capability object has already been establish, and is 2183fb1354edSrie * available in the calling file descriptor. 2184fb1354edSrie */ 2185fb1354edSrie if (flags & FLG_RT_HWCAP) { 2186fb1354edSrie if (cfdp->fd_lmp == 0) { 2187fb1354edSrie /* 2188fb1354edSrie * If this object hasn't yet been mapped, re-establish 2189fb1354edSrie * the file descriptor structure to reflect this objects 2190fb1354edSrie * original initial page mapping. Make sure any present 2191fb1354edSrie * file descriptor mapping is removed before overwriting 2192fb1354edSrie * the structure. 2193fb1354edSrie */ 2194fb1354edSrie #if defined(MAP_ALIGN) 2195fb1354edSrie if (fmap->fm_maddr && 2196fb1354edSrie ((fmap->fm_mflags & MAP_ALIGN) == 0)) 2197fb1354edSrie #else 2198fb1354edSrie if (fmap->fm_maddr) 2199fb1354edSrie #endif 2200fb1354edSrie (void) munmap(fmap->fm_maddr, fmap->fm_msize); 2201fb1354edSrie } 2202fb1354edSrie nfdp = *cfdp; 2203fb1354edSrie *fmap = cfdp->fd_fmap; 2204fb1354edSrie } 2205fb1354edSrie 2206fb1354edSrie lmp = _load_path(lml, lmco, name, clmp, nmode, flags, hdl, &nfdp, rej); 2207fb1354edSrie 2208fb1354edSrie /* 2209fb1354edSrie * If this path originated from a $HWCAP specification, re-establish the 2210fb1354edSrie * fdesc information. For single paged objects, such as filters, the 2211fb1354edSrie * original mapping may have been sufficient to capture the file, thus 2212fb1354edSrie * this mapping needs to be reset to insure it doesn't mistakenly get 2213fb1354edSrie * unmapped as part of HWCAP cleanup. 2214fb1354edSrie */ 2215fb1354edSrie if (flags & FLG_RT_HWCAP) { 2216fb1354edSrie cfdp->fd_fmap.fm_maddr = fmap->fm_maddr; 2217fb1354edSrie cfdp->fd_fmap.fm_mflags = fmap->fm_mflags; 2218fb1354edSrie cfdp->fd_fd = nfdp.fd_fd; 2219fb1354edSrie } 2220fb1354edSrie 2221fb1354edSrie return (lmp); 2222fb1354edSrie } 2223fb1354edSrie 2224390b98b5Srie /* 22257c478bd9Sstevel@tonic-gate * Load one object from a possible list of objects. Typically, for requests 22267c478bd9Sstevel@tonic-gate * such as NEEDED's, only one object is specified. However, this object could 22277c478bd9Sstevel@tonic-gate * be specified using $ISALIST or $HWCAP, in which case only the first object 22287c478bd9Sstevel@tonic-gate * that can be loaded is used (ie. the best). 22297c478bd9Sstevel@tonic-gate */ 22307c478bd9Sstevel@tonic-gate Rt_map * 22317c478bd9Sstevel@tonic-gate load_one(Lm_list *lml, Aliste lmco, Pnode *pnp, Rt_map *clmp, int mode, 22327c478bd9Sstevel@tonic-gate uint_t flags, Grp_hdl ** hdl) 22337c478bd9Sstevel@tonic-gate { 22347c478bd9Sstevel@tonic-gate Rej_desc rej = { 0 }; 22357c478bd9Sstevel@tonic-gate Pnode *tpnp; 22367c478bd9Sstevel@tonic-gate const char *name; 22377c478bd9Sstevel@tonic-gate Rt_map *tlmp; 22387c478bd9Sstevel@tonic-gate 22397c478bd9Sstevel@tonic-gate for (tpnp = pnp; tpnp && tpnp->p_name; tpnp = tpnp->p_next) { 22407c478bd9Sstevel@tonic-gate /* 22417c478bd9Sstevel@tonic-gate * A Hardware capabilities requirement can itself expand into 22427c478bd9Sstevel@tonic-gate * a number of candidates. 22437c478bd9Sstevel@tonic-gate */ 22447c478bd9Sstevel@tonic-gate if (tpnp->p_orig & PN_TKN_HWCAP) { 22457c478bd9Sstevel@tonic-gate if ((tlmp = load_hwcap(lml, lmco, tpnp->p_name, clmp, 22467c478bd9Sstevel@tonic-gate mode, (flags | FLG_RT_HWCAP), hdl, &rej)) != 0) { 22477c478bd9Sstevel@tonic-gate remove_rej(&rej); 22487c478bd9Sstevel@tonic-gate return (tlmp); 22497c478bd9Sstevel@tonic-gate } 22507c478bd9Sstevel@tonic-gate } else { 22517c478bd9Sstevel@tonic-gate if ((tlmp = load_path(lml, lmco, tpnp->p_name, clmp, 22527c478bd9Sstevel@tonic-gate mode, flags, hdl, 0, &rej)) != 0) { 22537c478bd9Sstevel@tonic-gate remove_rej(&rej); 22547c478bd9Sstevel@tonic-gate return (tlmp); 22557c478bd9Sstevel@tonic-gate } 22567c478bd9Sstevel@tonic-gate } 22577c478bd9Sstevel@tonic-gate } 22587c478bd9Sstevel@tonic-gate 22597c478bd9Sstevel@tonic-gate /* 22607c478bd9Sstevel@tonic-gate * If this pathname originated from an expanded token, use the original 22617c478bd9Sstevel@tonic-gate * for any diagnostic output. 22627c478bd9Sstevel@tonic-gate */ 22637c478bd9Sstevel@tonic-gate if ((name = pnp->p_oname) == 0) 22647c478bd9Sstevel@tonic-gate name = pnp->p_name; 22657c478bd9Sstevel@tonic-gate 22667c478bd9Sstevel@tonic-gate file_notfound(lml, name, clmp, flags, &rej); 22677c478bd9Sstevel@tonic-gate remove_rej(&rej); 22687c478bd9Sstevel@tonic-gate return (0); 22697c478bd9Sstevel@tonic-gate } 22707c478bd9Sstevel@tonic-gate 22717c478bd9Sstevel@tonic-gate /* 22727c478bd9Sstevel@tonic-gate * While processing direct or group bindings, determine whether the object to 22737c478bd9Sstevel@tonic-gate * which we've bound can be interposed upon. In this context, copy relocations 22747c478bd9Sstevel@tonic-gate * are a form of interposition. 22757c478bd9Sstevel@tonic-gate */ 22767c478bd9Sstevel@tonic-gate static Sym * 22777c478bd9Sstevel@tonic-gate lookup_sym_interpose(Slookup *slp, Rt_map **dlmp, uint_t *binfo, Lm_list * lml, 22787c478bd9Sstevel@tonic-gate Sym * sym) 22797c478bd9Sstevel@tonic-gate { 22807c478bd9Sstevel@tonic-gate Rt_map * lmp; 22817c478bd9Sstevel@tonic-gate Slookup sl; 22827c478bd9Sstevel@tonic-gate 22837c478bd9Sstevel@tonic-gate /* 22847c478bd9Sstevel@tonic-gate * If we've bound to a copy relocation definition then we need to assign 22857c478bd9Sstevel@tonic-gate * this binding to the original copy reference. Fabricate an inter- 22867c478bd9Sstevel@tonic-gate * position diagnostic, as this is a legitimate form of interposition. 22877c478bd9Sstevel@tonic-gate */ 22887c478bd9Sstevel@tonic-gate if (FLAGS1(*dlmp) & FL1_RT_COPYTOOK) { 22897c478bd9Sstevel@tonic-gate Rel_copy *rcp; 22907c478bd9Sstevel@tonic-gate Aliste off; 22917c478bd9Sstevel@tonic-gate 22927c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(COPY(*dlmp), off, rcp)) { 22937c478bd9Sstevel@tonic-gate if ((sym == rcp->r_dsym) || (sym->st_value && 22947c478bd9Sstevel@tonic-gate (sym->st_value == rcp->r_dsym->st_value))) { 22957c478bd9Sstevel@tonic-gate *dlmp = rcp->r_rlmp; 22967c478bd9Sstevel@tonic-gate *binfo |= 22977c478bd9Sstevel@tonic-gate (DBG_BINFO_INTERPOSE | DBG_BINFO_COPYREF); 22987c478bd9Sstevel@tonic-gate return (rcp->r_rsym); 22997c478bd9Sstevel@tonic-gate } 23007c478bd9Sstevel@tonic-gate } 23017c478bd9Sstevel@tonic-gate } 23027c478bd9Sstevel@tonic-gate 23037c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_INTRPOSE) == 0) 23047c478bd9Sstevel@tonic-gate return ((Sym *)0); 23057c478bd9Sstevel@tonic-gate 23067c478bd9Sstevel@tonic-gate /* 23077c478bd9Sstevel@tonic-gate * Traverse the list of known interposers to determine whether any 23087c478bd9Sstevel@tonic-gate * offer the same symbol. Note, the head of the link-map could be 23097c478bd9Sstevel@tonic-gate * identified as an interposer. If it is, make sure we only look for 23107c478bd9Sstevel@tonic-gate * symbol definitions. Otherwise, skip the head of the link-map, so 23117c478bd9Sstevel@tonic-gate * that we don't bind to any .plt references, or copy-relocations 23127c478bd9Sstevel@tonic-gate * unintentionally. 23137c478bd9Sstevel@tonic-gate */ 23147c478bd9Sstevel@tonic-gate lmp = lml->lm_head; 23157c478bd9Sstevel@tonic-gate sl = *slp; 23167c478bd9Sstevel@tonic-gate if (((FLAGS(lmp) & FLG_RT_INTRPOSE) == 0) || (sl.sl_flags & LKUP_COPY)) 23177c478bd9Sstevel@tonic-gate lmp = (Rt_map *)NEXT(lmp); 23187c478bd9Sstevel@tonic-gate else 23197c478bd9Sstevel@tonic-gate sl.sl_flags &= ~LKUP_SPEC; 23207c478bd9Sstevel@tonic-gate 23217c478bd9Sstevel@tonic-gate for (; lmp; lmp = (Rt_map *)NEXT(lmp)) { 23227c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_DELETE) 23237c478bd9Sstevel@tonic-gate continue; 23247c478bd9Sstevel@tonic-gate if ((FLAGS(lmp) & FLG_RT_INTRPOSE) == 0) 23257c478bd9Sstevel@tonic-gate break; 23267c478bd9Sstevel@tonic-gate 23277c478bd9Sstevel@tonic-gate if (callable(lmp, *dlmp, 0)) { 23287c478bd9Sstevel@tonic-gate sl.sl_imap = lmp; 23297c478bd9Sstevel@tonic-gate if (sym = SYMINTP(lmp)(&sl, dlmp, binfo)) { 23307c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_INTERPOSE; 23317c478bd9Sstevel@tonic-gate return (sym); 23327c478bd9Sstevel@tonic-gate } 23337c478bd9Sstevel@tonic-gate } 23347c478bd9Sstevel@tonic-gate } 23357c478bd9Sstevel@tonic-gate return ((Sym *)0); 23367c478bd9Sstevel@tonic-gate } 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate /* 23397c478bd9Sstevel@tonic-gate * If an object specifies direct bindings (it contains a syminfo structure 23407c478bd9Sstevel@tonic-gate * describing where each binding was established during link-editing, and the 23417c478bd9Sstevel@tonic-gate * object was built -Bdirect), then look for the symbol in the specific object. 23427c478bd9Sstevel@tonic-gate */ 23437c478bd9Sstevel@tonic-gate static Sym * 23447c478bd9Sstevel@tonic-gate lookup_sym_direct(Slookup *slp, Rt_map **dlmp, uint_t *binfo, Syminfo *sip, 23457c478bd9Sstevel@tonic-gate Rt_map *lmp) 23467c478bd9Sstevel@tonic-gate { 23477c478bd9Sstevel@tonic-gate Rt_map *clmp = slp->sl_cmap; 23487c478bd9Sstevel@tonic-gate Sym *sym; 23497c478bd9Sstevel@tonic-gate Slookup sl; 23507c478bd9Sstevel@tonic-gate 23517c478bd9Sstevel@tonic-gate /* 23527c478bd9Sstevel@tonic-gate * If a direct binding resolves to the definition of a copy relocated 23537c478bd9Sstevel@tonic-gate * variable, it must be redirected to the copy (in the executable) that 23547c478bd9Sstevel@tonic-gate * will eventually be made. Typically, this redirection occurs in 23557c478bd9Sstevel@tonic-gate * lookup_sym_interpose(). But, there's an edge condition. If a 23567c478bd9Sstevel@tonic-gate * directly bound executable contains pic code, there may be a 23577c478bd9Sstevel@tonic-gate * reference to a definition that will eventually have a copy made. 23587c478bd9Sstevel@tonic-gate * However, this copy relocation may not yet have occurred, because 23597c478bd9Sstevel@tonic-gate * the relocation making this reference comes before the relocation 23607c478bd9Sstevel@tonic-gate * that will create the copy. 23617c478bd9Sstevel@tonic-gate * Under direct bindings, the syminfo indicates that a copy will be 23627c478bd9Sstevel@tonic-gate * taken (SYMINFO_FLG_COPY). This can only be set in an executable. 23637c478bd9Sstevel@tonic-gate * Thus, the caller must be the executable, so bind to the destination 23647c478bd9Sstevel@tonic-gate * of the copy within the executable. 23657c478bd9Sstevel@tonic-gate */ 23667c478bd9Sstevel@tonic-gate if (((slp->sl_flags & LKUP_COPY) == 0) && 23677c478bd9Sstevel@tonic-gate (sip->si_flags & SYMINFO_FLG_COPY)) { 23687c478bd9Sstevel@tonic-gate 23697c478bd9Sstevel@tonic-gate slp->sl_imap = LIST(clmp)->lm_head; 23707c478bd9Sstevel@tonic-gate if (sym = SYMINTP(clmp)(slp, dlmp, binfo)) 23717c478bd9Sstevel@tonic-gate *binfo |= (DBG_BINFO_DIRECT | DBG_BINFO_COPYREF); 23727c478bd9Sstevel@tonic-gate return (sym); 23737c478bd9Sstevel@tonic-gate } 23747c478bd9Sstevel@tonic-gate 23757c478bd9Sstevel@tonic-gate /* 23767c478bd9Sstevel@tonic-gate * If we need to direct bind to our parent start looking in each caller 23777c478bd9Sstevel@tonic-gate * link map. 23787c478bd9Sstevel@tonic-gate */ 23797c478bd9Sstevel@tonic-gate sl = *slp; 23807c478bd9Sstevel@tonic-gate sl.sl_flags |= LKUP_DIRECT; 23817c478bd9Sstevel@tonic-gate sym = 0; 23827c478bd9Sstevel@tonic-gate 23837c478bd9Sstevel@tonic-gate if (sip->si_boundto == SYMINFO_BT_PARENT) { 23847c478bd9Sstevel@tonic-gate Aliste off; 23857c478bd9Sstevel@tonic-gate Bnd_desc ** bdpp; 23867c478bd9Sstevel@tonic-gate 23877c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(CALLERS(clmp), off, bdpp)) { 23887c478bd9Sstevel@tonic-gate sl.sl_imap = lmp = (*bdpp)->b_caller; 23897c478bd9Sstevel@tonic-gate if ((sym = SYMINTP(lmp)(&sl, dlmp, binfo)) != 0) 23907c478bd9Sstevel@tonic-gate break; 23917c478bd9Sstevel@tonic-gate } 23927c478bd9Sstevel@tonic-gate } else { 23937c478bd9Sstevel@tonic-gate /* 23947c478bd9Sstevel@tonic-gate * If we need to direct bind to anything else look in the 23957c478bd9Sstevel@tonic-gate * link map associated with this symbol reference. 23967c478bd9Sstevel@tonic-gate */ 23977c478bd9Sstevel@tonic-gate if (sip->si_boundto == SYMINFO_BT_SELF) 23987c478bd9Sstevel@tonic-gate sl.sl_imap = lmp = clmp; 23997c478bd9Sstevel@tonic-gate else 24007c478bd9Sstevel@tonic-gate sl.sl_imap = lmp; 24017c478bd9Sstevel@tonic-gate 24027c478bd9Sstevel@tonic-gate if (lmp) 24037c478bd9Sstevel@tonic-gate sym = SYMINTP(lmp)(&sl, dlmp, binfo); 24047c478bd9Sstevel@tonic-gate } 24057c478bd9Sstevel@tonic-gate 24067c478bd9Sstevel@tonic-gate if (sym) 24077c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_DIRECT; 24087c478bd9Sstevel@tonic-gate 24097c478bd9Sstevel@tonic-gate /* 24107c478bd9Sstevel@tonic-gate * If we've bound to an object, determine whether that object can be 24117c478bd9Sstevel@tonic-gate * interposed upon for this symbol. 24127c478bd9Sstevel@tonic-gate */ 24137c478bd9Sstevel@tonic-gate if (sym && (LIST(*dlmp)->lm_head != *dlmp) && 24147c478bd9Sstevel@tonic-gate (LIST(*dlmp) == LIST(clmp))) { 24157c478bd9Sstevel@tonic-gate Sym * isym; 24167c478bd9Sstevel@tonic-gate 24177c478bd9Sstevel@tonic-gate if ((isym = lookup_sym_interpose(slp, dlmp, binfo, 24187c478bd9Sstevel@tonic-gate LIST(*dlmp), sym)) != 0) 24197c478bd9Sstevel@tonic-gate return (isym); 24207c478bd9Sstevel@tonic-gate } 24217c478bd9Sstevel@tonic-gate 24227c478bd9Sstevel@tonic-gate return (sym); 24237c478bd9Sstevel@tonic-gate } 24247c478bd9Sstevel@tonic-gate 24257c478bd9Sstevel@tonic-gate static Sym * 24267c478bd9Sstevel@tonic-gate _lookup_sym(Rt_map *ilmp, Slookup *slp, Rt_map **dlmp, uint_t *binfo, 24277c478bd9Sstevel@tonic-gate Aliste off) 24287c478bd9Sstevel@tonic-gate { 24297c478bd9Sstevel@tonic-gate Rt_map *lmp; 24307c478bd9Sstevel@tonic-gate 24317c478bd9Sstevel@tonic-gate /* 24327c478bd9Sstevel@tonic-gate * Copy relocations should start their search after the head of the 24337c478bd9Sstevel@tonic-gate * main link-map control list. 24347c478bd9Sstevel@tonic-gate */ 24357c478bd9Sstevel@tonic-gate if ((off == ALO_DATA) && (slp->sl_flags & LKUP_COPY) && ilmp) 24367c478bd9Sstevel@tonic-gate lmp = (Rt_map *)NEXT(ilmp); 24377c478bd9Sstevel@tonic-gate else 24387c478bd9Sstevel@tonic-gate lmp = ilmp; 24397c478bd9Sstevel@tonic-gate 24407c478bd9Sstevel@tonic-gate for (; lmp; lmp = (Rt_map *)NEXT(lmp)) { 24417c478bd9Sstevel@tonic-gate if (callable(slp->sl_cmap, lmp, 0)) { 24427c478bd9Sstevel@tonic-gate Sym *sym; 24437c478bd9Sstevel@tonic-gate 24447c478bd9Sstevel@tonic-gate slp->sl_imap = lmp; 24457c478bd9Sstevel@tonic-gate if ((sym = SYMINTP(lmp)(slp, dlmp, binfo)) != 0) 24467c478bd9Sstevel@tonic-gate return (sym); 24477c478bd9Sstevel@tonic-gate } 24487c478bd9Sstevel@tonic-gate } 24497c478bd9Sstevel@tonic-gate return (0); 24507c478bd9Sstevel@tonic-gate } 24517c478bd9Sstevel@tonic-gate 24527c478bd9Sstevel@tonic-gate static Sym * 24537c478bd9Sstevel@tonic-gate _lazy_find_sym(Rt_map *ilmp, Slookup *slp, Rt_map **dlmp, uint_t *binfo) 24547c478bd9Sstevel@tonic-gate { 24557c478bd9Sstevel@tonic-gate Rt_map *lmp; 24567c478bd9Sstevel@tonic-gate 24577c478bd9Sstevel@tonic-gate for (lmp = ilmp; lmp; lmp = (Rt_map *)NEXT(lmp)) { 24587c478bd9Sstevel@tonic-gate if (LAZY(lmp) == 0) 24597c478bd9Sstevel@tonic-gate continue; 24607c478bd9Sstevel@tonic-gate if (callable(slp->sl_cmap, lmp, 0)) { 24617c478bd9Sstevel@tonic-gate Sym *sym; 24627c478bd9Sstevel@tonic-gate 24637c478bd9Sstevel@tonic-gate slp->sl_imap = lmp; 24647c478bd9Sstevel@tonic-gate if ((sym = elf_lazy_find_sym(slp, dlmp, binfo)) != 0) 24657c478bd9Sstevel@tonic-gate return (sym); 24667c478bd9Sstevel@tonic-gate } 24677c478bd9Sstevel@tonic-gate } 24687c478bd9Sstevel@tonic-gate return (0); 24697c478bd9Sstevel@tonic-gate } 24707c478bd9Sstevel@tonic-gate 24717c478bd9Sstevel@tonic-gate /* 24727c478bd9Sstevel@tonic-gate * Symbol lookup routine. Takes an ELF symbol name, and a list of link maps to 24737c478bd9Sstevel@tonic-gate * search (if the flag indicates LKUP_FIRST only the first link map of the list 24747c478bd9Sstevel@tonic-gate * is searched ie. we've been called from dlsym()). 24757c478bd9Sstevel@tonic-gate * If successful, return a pointer to the symbol table entry and a pointer to 24767c478bd9Sstevel@tonic-gate * the link map of the enclosing object. Else return a null pointer. 24777c478bd9Sstevel@tonic-gate * 24787c478bd9Sstevel@tonic-gate * To improve elf performance, we first compute the elf hash value and pass 24797c478bd9Sstevel@tonic-gate * it to each find_sym() routine. The elf function will use this value to 24807c478bd9Sstevel@tonic-gate * locate the symbol, the a.out function will simply ignore it. 24817c478bd9Sstevel@tonic-gate */ 24827c478bd9Sstevel@tonic-gate Sym * 24837c478bd9Sstevel@tonic-gate lookup_sym(Slookup *slp, Rt_map **dlmp, uint_t *binfo) 24847c478bd9Sstevel@tonic-gate { 24857c478bd9Sstevel@tonic-gate const char *name = slp->sl_name; 24867c478bd9Sstevel@tonic-gate Rt_map *clmp = slp->sl_cmap; 24877c478bd9Sstevel@tonic-gate Rt_map *ilmp = slp->sl_imap, *lmp; 24887c478bd9Sstevel@tonic-gate uint_t flags = slp->sl_flags; 24897c478bd9Sstevel@tonic-gate ulong_t rsymndx; 24907c478bd9Sstevel@tonic-gate Sym *sym = 0; 24917c478bd9Sstevel@tonic-gate Syminfo *sip; 24927c478bd9Sstevel@tonic-gate Slookup sl; 24937c478bd9Sstevel@tonic-gate 24947c478bd9Sstevel@tonic-gate if (slp->sl_hash == 0) 24957c478bd9Sstevel@tonic-gate slp->sl_hash = elf_hash(name); 24967c478bd9Sstevel@tonic-gate *binfo = 0; 24977c478bd9Sstevel@tonic-gate 24987c478bd9Sstevel@tonic-gate /* 24997c478bd9Sstevel@tonic-gate * Search the initial link map for the required symbol (this category is 25007c478bd9Sstevel@tonic-gate * selected by dlsym(), where individual link maps are searched for a 25017c478bd9Sstevel@tonic-gate * required symbol. Therefore, we know we have permission to look at 25027c478bd9Sstevel@tonic-gate * the link map). 25037c478bd9Sstevel@tonic-gate */ 25047c478bd9Sstevel@tonic-gate if (flags & LKUP_FIRST) 25057c478bd9Sstevel@tonic-gate return (SYMINTP(ilmp)(slp, dlmp, binfo)); 25067c478bd9Sstevel@tonic-gate 25077c478bd9Sstevel@tonic-gate /* 25087c478bd9Sstevel@tonic-gate * Determine whether this lookup can be satisfied by an objects direct, 25097c478bd9Sstevel@tonic-gate * or lazy binding information. This is triggered by a relocation from 25107c478bd9Sstevel@tonic-gate * the object (hence rsymndx is set). 25117c478bd9Sstevel@tonic-gate */ 25127c478bd9Sstevel@tonic-gate if (((rsymndx = slp->sl_rsymndx) != 0) && 25137c478bd9Sstevel@tonic-gate ((sip = SYMINFO(clmp)) != 0)) { 25147c478bd9Sstevel@tonic-gate 25157c478bd9Sstevel@tonic-gate /* 25167c478bd9Sstevel@tonic-gate * Find the corresponding Syminfo entry for the original 25177c478bd9Sstevel@tonic-gate * referencing symbol. 25187c478bd9Sstevel@tonic-gate */ 25197c478bd9Sstevel@tonic-gate /* LINTED */ 25207c478bd9Sstevel@tonic-gate sip = (Syminfo *)((char *)sip + (rsymndx * SYMINENT(clmp))); 25217c478bd9Sstevel@tonic-gate 25227c478bd9Sstevel@tonic-gate /* 25237c478bd9Sstevel@tonic-gate * If the symbol information indicates a direct binding, 25247c478bd9Sstevel@tonic-gate * determine the link map that is required to satisfy the 25257c478bd9Sstevel@tonic-gate * binding. Note, if the dependency can not be found, but a 25267c478bd9Sstevel@tonic-gate * direct binding isn't required, we will still fall through 25277c478bd9Sstevel@tonic-gate * to perform any default symbol search. 25287c478bd9Sstevel@tonic-gate */ 25297c478bd9Sstevel@tonic-gate if (sip->si_flags & SYMINFO_FLG_DIRECT) { 25307c478bd9Sstevel@tonic-gate uint_t bound = sip->si_boundto; 25317c478bd9Sstevel@tonic-gate 25327c478bd9Sstevel@tonic-gate lmp = 0; 25337c478bd9Sstevel@tonic-gate if (bound < SYMINFO_BT_LOWRESERVE) 25347c478bd9Sstevel@tonic-gate lmp = elf_lazy_load(clmp, bound, name); 25357c478bd9Sstevel@tonic-gate 25367c478bd9Sstevel@tonic-gate /* 25377c478bd9Sstevel@tonic-gate * If direct bindings have been disabled, and this isn't 25387c478bd9Sstevel@tonic-gate * a translator, skip any direct binding now that we've 25397c478bd9Sstevel@tonic-gate * insured the resolving object has been loaded. 25407c478bd9Sstevel@tonic-gate * 25417c478bd9Sstevel@tonic-gate * If we need to direct bind to anything, we look in 25427c478bd9Sstevel@tonic-gate * ourselves, our parent, or in the link map we've just 25437c478bd9Sstevel@tonic-gate * loaded. Otherwise, even though we may have lazily 25447c478bd9Sstevel@tonic-gate * loaded an object we still continue to search for 25457c478bd9Sstevel@tonic-gate * symbols from the head of the link map list. 25467c478bd9Sstevel@tonic-gate */ 25477c478bd9Sstevel@tonic-gate if (((FLAGS(clmp) & FLG_RT_TRANS) || 25487c478bd9Sstevel@tonic-gate (!(LIST(clmp)->lm_tflags & LML_TFLG_NODIRECT))) && 25497c478bd9Sstevel@tonic-gate ((FLAGS(clmp) & FLG_RT_DIRECT) || 25507c478bd9Sstevel@tonic-gate (sip->si_flags & SYMINFO_FLG_DIRECTBIND))) { 25517c478bd9Sstevel@tonic-gate sym = lookup_sym_direct(slp, dlmp, binfo, 25527c478bd9Sstevel@tonic-gate sip, lmp); 25537c478bd9Sstevel@tonic-gate 25547c478bd9Sstevel@tonic-gate /* 25557c478bd9Sstevel@tonic-gate * If this direct binding has been disabled 25567c478bd9Sstevel@tonic-gate * (presumably because the symbol definition has 25577c478bd9Sstevel@tonic-gate * been changed since the referring object was 25587c478bd9Sstevel@tonic-gate * built), fall back to a standard symbol 25597c478bd9Sstevel@tonic-gate * search. 25607c478bd9Sstevel@tonic-gate */ 25617c478bd9Sstevel@tonic-gate if ((*binfo & BINFO_DIRECTDIS) == 0) 25627c478bd9Sstevel@tonic-gate return (sym); 25637c478bd9Sstevel@tonic-gate } 25647c478bd9Sstevel@tonic-gate } 25657c478bd9Sstevel@tonic-gate } 25667c478bd9Sstevel@tonic-gate 25677c478bd9Sstevel@tonic-gate sl = *slp; 25687c478bd9Sstevel@tonic-gate 25697c478bd9Sstevel@tonic-gate /* 25707c478bd9Sstevel@tonic-gate * If the referencing object has the DF_SYMBOLIC flag set, look in the 25717c478bd9Sstevel@tonic-gate * referencing object for the symbol first. Failing that, fall back to 25727c478bd9Sstevel@tonic-gate * our generic search. 25737c478bd9Sstevel@tonic-gate */ 25747c478bd9Sstevel@tonic-gate if (FLAGS1(clmp) & FL1_RT_SYMBOLIC) { 25757c478bd9Sstevel@tonic-gate sl.sl_imap = clmp; 25767c478bd9Sstevel@tonic-gate if (sym = SYMINTP(clmp)(&sl, dlmp, binfo)) 25777c478bd9Sstevel@tonic-gate return (sym); 25787c478bd9Sstevel@tonic-gate } 25797c478bd9Sstevel@tonic-gate 25807c478bd9Sstevel@tonic-gate /* 25817c478bd9Sstevel@tonic-gate * If this lookup originates from a standard relocation, then traverse 25827c478bd9Sstevel@tonic-gate * all link-map lists inspecting any object that is available to this 25837c478bd9Sstevel@tonic-gate * caller. Otherwise, traverse the link-map list associate with the 25847c478bd9Sstevel@tonic-gate * caller. 25857c478bd9Sstevel@tonic-gate */ 25867c478bd9Sstevel@tonic-gate if (flags & LKUP_ALLCNTLIST) { 25877c478bd9Sstevel@tonic-gate Aliste off; 25887c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 25897c478bd9Sstevel@tonic-gate 25907c478bd9Sstevel@tonic-gate sym = 0; 25917c478bd9Sstevel@tonic-gate 25927c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(LIST(clmp)->lm_lists, off, lmc)) { 25937c478bd9Sstevel@tonic-gate if ((sym = _lookup_sym(lmc->lc_head, &sl, dlmp, 25947c478bd9Sstevel@tonic-gate binfo, off)) != 0) 25957c478bd9Sstevel@tonic-gate break; 25967c478bd9Sstevel@tonic-gate } 25977c478bd9Sstevel@tonic-gate } else 25987c478bd9Sstevel@tonic-gate sym = _lookup_sym(ilmp, &sl, dlmp, binfo, ALO_DATA); 25997c478bd9Sstevel@tonic-gate 26007c478bd9Sstevel@tonic-gate /* 26017c478bd9Sstevel@tonic-gate * To allow transitioning into a world of lazy loading dependencies see 26027c478bd9Sstevel@tonic-gate * if this link map contains objects that have lazy dependencies still 26037c478bd9Sstevel@tonic-gate * outstanding. If so, and we haven't been able to locate a non-weak 26047c478bd9Sstevel@tonic-gate * symbol reference, start bringing in any lazy dependencies to see if 26057c478bd9Sstevel@tonic-gate * the reference can be satisfied. Use of dlsym(RTLD_PROBE) sets the 26067c478bd9Sstevel@tonic-gate * LKUP_NOFALBACK flag, and this flag disables this fall back. 26077c478bd9Sstevel@tonic-gate */ 26087c478bd9Sstevel@tonic-gate if ((sym == 0) && ((sl.sl_flags & LKUP_NOFALBACK) == 0)) { 26097c478bd9Sstevel@tonic-gate if ((lmp = ilmp) == 0) 26107c478bd9Sstevel@tonic-gate lmp = LIST(clmp)->lm_head; 26117c478bd9Sstevel@tonic-gate if ((flags & LKUP_WEAK) || (LIST(lmp)->lm_lazy == 0)) 26127c478bd9Sstevel@tonic-gate return ((Sym *)0); 26137c478bd9Sstevel@tonic-gate 2614*5aefb655Srie DBG_CALL(Dbg_syms_lazy_rescan(LIST(clmp), name)); 26157c478bd9Sstevel@tonic-gate 26167c478bd9Sstevel@tonic-gate /* 26177c478bd9Sstevel@tonic-gate * If this request originated from a dlsym(RTLD_NEXT) then start 26187c478bd9Sstevel@tonic-gate * looking for dependencies from the caller, otherwise use the 26197c478bd9Sstevel@tonic-gate * initial link-map. 26207c478bd9Sstevel@tonic-gate */ 26217c478bd9Sstevel@tonic-gate if (flags & LKUP_NEXT) 26227c478bd9Sstevel@tonic-gate sym = _lazy_find_sym(clmp, &sl, dlmp, binfo); 26237c478bd9Sstevel@tonic-gate else { 26247c478bd9Sstevel@tonic-gate Aliste off; 26257c478bd9Sstevel@tonic-gate Lm_cntl *lmc; 26267c478bd9Sstevel@tonic-gate 26277c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(LIST(clmp)->lm_lists, off, lmc)) { 26287c478bd9Sstevel@tonic-gate sl.sl_flags |= LKUP_NOFALBACK; 26297c478bd9Sstevel@tonic-gate if ((sym = _lazy_find_sym(lmc->lc_head, &sl, 26307c478bd9Sstevel@tonic-gate dlmp, binfo)) != 0) 26317c478bd9Sstevel@tonic-gate break; 26327c478bd9Sstevel@tonic-gate } 26337c478bd9Sstevel@tonic-gate } 26347c478bd9Sstevel@tonic-gate } 26357c478bd9Sstevel@tonic-gate 26367c478bd9Sstevel@tonic-gate /* 26377c478bd9Sstevel@tonic-gate * If the caller is restricted to a symbol search within its group, 26387c478bd9Sstevel@tonic-gate * determine if it is necessary to follow a binding from outside of 26397c478bd9Sstevel@tonic-gate * the group. 26407c478bd9Sstevel@tonic-gate */ 26417c478bd9Sstevel@tonic-gate if (sym && ((MODE(clmp) & (RTLD_GROUP | RTLD_WORLD)) == RTLD_GROUP)) { 26427c478bd9Sstevel@tonic-gate Sym * isym; 26437c478bd9Sstevel@tonic-gate 26447c478bd9Sstevel@tonic-gate if ((isym = lookup_sym_interpose(slp, dlmp, binfo, LIST(*dlmp), 26457c478bd9Sstevel@tonic-gate sym)) != 0) 26467c478bd9Sstevel@tonic-gate return (isym); 26477c478bd9Sstevel@tonic-gate } 26487c478bd9Sstevel@tonic-gate return (sym); 26497c478bd9Sstevel@tonic-gate } 26507c478bd9Sstevel@tonic-gate 26517c478bd9Sstevel@tonic-gate /* 26527c478bd9Sstevel@tonic-gate * Associate a binding descriptor with a caller and its dependency, or update 26537c478bd9Sstevel@tonic-gate * an existing descriptor. 26547c478bd9Sstevel@tonic-gate */ 26557c478bd9Sstevel@tonic-gate int 26567c478bd9Sstevel@tonic-gate bind_one(Rt_map *clmp, Rt_map *dlmp, uint_t flags) 26577c478bd9Sstevel@tonic-gate { 26587c478bd9Sstevel@tonic-gate Bnd_desc **bdpp, *bdp; 26597c478bd9Sstevel@tonic-gate Aliste off; 26607c478bd9Sstevel@tonic-gate int found = ALE_CREATE; 26617c478bd9Sstevel@tonic-gate 26627c478bd9Sstevel@tonic-gate /* 26637c478bd9Sstevel@tonic-gate * Determine whether a binding descriptor already exists between the 26647c478bd9Sstevel@tonic-gate * two objects. 26657c478bd9Sstevel@tonic-gate */ 26667c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(DEPENDS(clmp), off, bdpp)) { 26677c478bd9Sstevel@tonic-gate bdp = *bdpp; 26687c478bd9Sstevel@tonic-gate 26697c478bd9Sstevel@tonic-gate if (bdp->b_depend == dlmp) { 26707c478bd9Sstevel@tonic-gate found = ALE_EXISTS; 26717c478bd9Sstevel@tonic-gate break; 26727c478bd9Sstevel@tonic-gate } 26737c478bd9Sstevel@tonic-gate } 26747c478bd9Sstevel@tonic-gate 26757c478bd9Sstevel@tonic-gate if (found == ALE_CREATE) { 26767c478bd9Sstevel@tonic-gate /* 26777c478bd9Sstevel@tonic-gate * Create a new binding descriptor. 26787c478bd9Sstevel@tonic-gate */ 26797c478bd9Sstevel@tonic-gate if ((bdp = malloc(sizeof (Bnd_desc))) == 0) 26807c478bd9Sstevel@tonic-gate return (0); 26817c478bd9Sstevel@tonic-gate 26827c478bd9Sstevel@tonic-gate bdp->b_caller = clmp; 26837c478bd9Sstevel@tonic-gate bdp->b_depend = dlmp; 26847c478bd9Sstevel@tonic-gate bdp->b_flags = 0; 26857c478bd9Sstevel@tonic-gate 26867c478bd9Sstevel@tonic-gate /* 26877c478bd9Sstevel@tonic-gate * Append the binding descriptor to the caller and the 26887c478bd9Sstevel@tonic-gate * dependency. 26897c478bd9Sstevel@tonic-gate */ 26907c478bd9Sstevel@tonic-gate if (alist_append(&DEPENDS(clmp), &bdp, 26917c478bd9Sstevel@tonic-gate sizeof (Bnd_desc *), AL_CNT_DEPENDS) == 0) 26927c478bd9Sstevel@tonic-gate return (0); 26937c478bd9Sstevel@tonic-gate 26947c478bd9Sstevel@tonic-gate if (alist_append(&CALLERS(dlmp), &bdp, 26957c478bd9Sstevel@tonic-gate sizeof (Bnd_desc *), AL_CNT_CALLERS) == 0) 26967c478bd9Sstevel@tonic-gate return (0); 26977c478bd9Sstevel@tonic-gate } 26987c478bd9Sstevel@tonic-gate 26997c478bd9Sstevel@tonic-gate if ((found == ALE_CREATE) || ((bdp->b_flags & flags) != flags)) { 27007c478bd9Sstevel@tonic-gate bdp->b_flags |= flags; 27017c478bd9Sstevel@tonic-gate 27027c478bd9Sstevel@tonic-gate if (flags & BND_REFER) 27037c478bd9Sstevel@tonic-gate FLAGS1(dlmp) |= FL1_RT_USED; 27047c478bd9Sstevel@tonic-gate 2705*5aefb655Srie DBG_CALL(Dbg_file_bind_entry(LIST(clmp), bdp)); 27067c478bd9Sstevel@tonic-gate } 27077c478bd9Sstevel@tonic-gate return (found); 27087c478bd9Sstevel@tonic-gate } 27097c478bd9Sstevel@tonic-gate 27107c478bd9Sstevel@tonic-gate /* 27117c478bd9Sstevel@tonic-gate * Cleanup after relocation processing. 27127c478bd9Sstevel@tonic-gate */ 27137c478bd9Sstevel@tonic-gate int 27147c478bd9Sstevel@tonic-gate relocate_finish(Rt_map *lmp, Alist *bound, int textrel, int ret) 27157c478bd9Sstevel@tonic-gate { 2716*5aefb655Srie DBG_CALL(Dbg_reloc_run(lmp, 0, ret, DBG_REL_FINISH)); 27177c478bd9Sstevel@tonic-gate 27187c478bd9Sstevel@tonic-gate /* 27197c478bd9Sstevel@tonic-gate * Establish bindings to all objects that have been bound to. 27207c478bd9Sstevel@tonic-gate */ 27217c478bd9Sstevel@tonic-gate if (bound) { 27227c478bd9Sstevel@tonic-gate Aliste off; 27237c478bd9Sstevel@tonic-gate Rt_map **lmpp; 27247c478bd9Sstevel@tonic-gate 27257c478bd9Sstevel@tonic-gate if (ret) { 27267c478bd9Sstevel@tonic-gate for (ALIST_TRAVERSE(bound, off, lmpp)) { 27277c478bd9Sstevel@tonic-gate if (bind_one(lmp, *lmpp, BND_REFER) == 0) { 27287c478bd9Sstevel@tonic-gate ret = 0; 27297c478bd9Sstevel@tonic-gate break; 27307c478bd9Sstevel@tonic-gate } 27317c478bd9Sstevel@tonic-gate } 27327c478bd9Sstevel@tonic-gate } 27337c478bd9Sstevel@tonic-gate free(bound); 27347c478bd9Sstevel@tonic-gate } 27357c478bd9Sstevel@tonic-gate 27367c478bd9Sstevel@tonic-gate /* 27377c478bd9Sstevel@tonic-gate * If we write enabled the text segment to perform these relocations 27387c478bd9Sstevel@tonic-gate * re-protect by disabling writes. 27397c478bd9Sstevel@tonic-gate */ 27407c478bd9Sstevel@tonic-gate if (textrel) 27417c478bd9Sstevel@tonic-gate (void) LM_SET_PROT(lmp)(lmp, 0); 27427c478bd9Sstevel@tonic-gate 27437c478bd9Sstevel@tonic-gate return (ret); 27447c478bd9Sstevel@tonic-gate } 2745