17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 55aefb655Srie * Common Development and Distribution License (the "License"). 65aefb655Srie * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 2111a2bb38Srie 227257d1b4Sraf /* 237257d1b4Sraf * Copyright (c) 1988 AT&T 247257d1b4Sraf * All Rights Reserved 25f441771bSRod Evans * 26f441771bSRod Evans * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved. 277257d1b4Sraf */ 28b533f56bSRobert Mustacchi /* 29b533f56bSRobert Mustacchi * Copyright (c) 2012, Joyent, Inc. All rights reserved. 30b533f56bSRobert Mustacchi */ 317257d1b4Sraf 327c478bd9Sstevel@tonic-gate /* 337c478bd9Sstevel@tonic-gate * Object file dependent support for ELF objects. 347c478bd9Sstevel@tonic-gate */ 357c478bd9Sstevel@tonic-gate 367c478bd9Sstevel@tonic-gate #include <stdio.h> 377c478bd9Sstevel@tonic-gate #include <sys/procfs.h> 387c478bd9Sstevel@tonic-gate #include <sys/mman.h> 397c478bd9Sstevel@tonic-gate #include <sys/debug.h> 407c478bd9Sstevel@tonic-gate #include <string.h> 417c478bd9Sstevel@tonic-gate #include <limits.h> 427c478bd9Sstevel@tonic-gate #include <dlfcn.h> 435aefb655Srie #include <debug.h> 445aefb655Srie #include <conv.h> 457c478bd9Sstevel@tonic-gate #include "_rtld.h" 467c478bd9Sstevel@tonic-gate #include "_audit.h" 477c478bd9Sstevel@tonic-gate #include "_elf.h" 48f441771bSRod Evans #include "_inline_gen.h" 49f441771bSRod Evans #include "_inline_reloc.h" 507c478bd9Sstevel@tonic-gate #include "msg.h" 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate /* 537c478bd9Sstevel@tonic-gate * Default and secure dependency search paths. 547c478bd9Sstevel@tonic-gate */ 5556deab07SRod Evans static Spath_defn _elf_def_dirs[] = { 567c478bd9Sstevel@tonic-gate #if defined(_ELF64) 5756deab07SRod Evans { MSG_ORIG(MSG_PTH_LIB_64), MSG_PTH_LIB_64_SIZE }, 5856deab07SRod Evans { MSG_ORIG(MSG_PTH_USRLIB_64), MSG_PTH_USRLIB_64_SIZE }, 597c478bd9Sstevel@tonic-gate #else 6056deab07SRod Evans { MSG_ORIG(MSG_PTH_LIB), MSG_PTH_LIB_SIZE }, 6156deab07SRod Evans { MSG_ORIG(MSG_PTH_USRLIB), MSG_PTH_USRLIB_SIZE }, 627c478bd9Sstevel@tonic-gate #endif 6356deab07SRod Evans { 0, 0 } 647c478bd9Sstevel@tonic-gate }; 657c478bd9Sstevel@tonic-gate 6656deab07SRod Evans static Spath_defn _elf_sec_dirs[] = { 677c478bd9Sstevel@tonic-gate #if defined(_ELF64) 6856deab07SRod Evans { MSG_ORIG(MSG_PTH_LIBSE_64), MSG_PTH_LIBSE_64_SIZE }, 6956deab07SRod Evans { MSG_ORIG(MSG_PTH_USRLIBSE_64), MSG_PTH_USRLIBSE_64_SIZE }, 707c478bd9Sstevel@tonic-gate #else 7156deab07SRod Evans { MSG_ORIG(MSG_PTH_LIBSE), MSG_PTH_LIBSE_SIZE }, 7256deab07SRod Evans { MSG_ORIG(MSG_PTH_USRLIBSE), MSG_PTH_USRLIBSE_SIZE }, 737c478bd9Sstevel@tonic-gate #endif 7456deab07SRod Evans { 0, 0 } 757c478bd9Sstevel@tonic-gate }; 767c478bd9Sstevel@tonic-gate 7756deab07SRod Evans Alist *elf_def_dirs = NULL; 7856deab07SRod Evans Alist *elf_sec_dirs = NULL; 7956deab07SRod Evans 807c478bd9Sstevel@tonic-gate /* 817c478bd9Sstevel@tonic-gate * Defines for local functions. 827c478bd9Sstevel@tonic-gate */ 837c478bd9Sstevel@tonic-gate static void elf_dladdr(ulong_t, Rt_map *, Dl_info *, void **, int); 8456deab07SRod Evans static Addr elf_entry_point(void); 8556deab07SRod Evans static int elf_fix_name(const char *, Rt_map *, Alist **, Aliste, uint_t); 8656deab07SRod Evans static Alist **elf_get_def_dirs(void); 8756deab07SRod Evans static Alist **elf_get_sec_dirs(void); 8856deab07SRod Evans static char *elf_get_so(const char *, const char *, size_t, size_t); 899aa23310Srie static int elf_needed(Lm_list *, Aliste, Rt_map *, int *); 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate /* 927c478bd9Sstevel@tonic-gate * Functions and data accessed through indirect pointers. 937c478bd9Sstevel@tonic-gate */ 947c478bd9Sstevel@tonic-gate Fct elf_fct = { 9556deab07SRod Evans elf_verify, 9656deab07SRod Evans elf_new_lmp, 9756deab07SRod Evans elf_entry_point, 987c478bd9Sstevel@tonic-gate elf_needed, 997c478bd9Sstevel@tonic-gate lookup_sym, 1007c478bd9Sstevel@tonic-gate elf_reloc, 10156deab07SRod Evans elf_get_def_dirs, 10256deab07SRod Evans elf_get_sec_dirs, 1037c478bd9Sstevel@tonic-gate elf_fix_name, 1047c478bd9Sstevel@tonic-gate elf_get_so, 1057c478bd9Sstevel@tonic-gate elf_dladdr, 10656deab07SRod Evans dlsym_handle 1077c478bd9Sstevel@tonic-gate }; 1087c478bd9Sstevel@tonic-gate 10956deab07SRod Evans /* 11056deab07SRod Evans * Default and secure dependency search paths. 11156deab07SRod Evans */ 11256deab07SRod Evans static Alist ** 11356deab07SRod Evans elf_get_def_dirs() 11456deab07SRod Evans { 11556deab07SRod Evans if (elf_def_dirs == NULL) 11656deab07SRod Evans set_dirs(&elf_def_dirs, _elf_def_dirs, LA_SER_DEFAULT); 11756deab07SRod Evans return (&elf_def_dirs); 11856deab07SRod Evans } 11956deab07SRod Evans 12056deab07SRod Evans static Alist ** 12156deab07SRod Evans elf_get_sec_dirs() 12256deab07SRod Evans { 12356deab07SRod Evans if (elf_sec_dirs == NULL) 12456deab07SRod Evans set_dirs(&elf_sec_dirs, _elf_sec_dirs, LA_SER_SECURE); 12556deab07SRod Evans return (&elf_sec_dirs); 12656deab07SRod Evans } 1277c478bd9Sstevel@tonic-gate 1287c478bd9Sstevel@tonic-gate /* 129*0904e7ecSRichard Lowe * For a.out we have actual work to do here, on ELF we just perform path 130*0904e7ecSRichard Lowe * expansion. 1317c478bd9Sstevel@tonic-gate */ 13256deab07SRod Evans static int 13356deab07SRod Evans elf_fix_name(const char *name, Rt_map *clmp, Alist **alpp, Aliste alni, 13456deab07SRod Evans uint_t orig) 1357c478bd9Sstevel@tonic-gate { 13656deab07SRod Evans return (expand_paths(clmp, name, alpp, alni, orig, 0)); 13756deab07SRod Evans } 13856deab07SRod Evans 13956deab07SRod Evans /* 14008278a5eSRod Evans * Determine whether this object requires capabilities. 14156deab07SRod Evans */ 14208278a5eSRod Evans inline static int 14356deab07SRod Evans elf_cap_check(Fdesc *fdp, Ehdr *ehdr, Rej_desc *rej) 14456deab07SRod Evans { 14556deab07SRod Evans Phdr *phdr; 14608278a5eSRod Evans Cap *cap = NULL; 14708278a5eSRod Evans Dyn *dyn = NULL; 14808278a5eSRod Evans char *str = NULL; 14908278a5eSRod Evans Addr base; 150f441771bSRod Evans uint_t cnt, dyncnt; 15156deab07SRod Evans 15208278a5eSRod Evans /* 15308278a5eSRod Evans * If this is a shared object, the base address of the shared object is 15408278a5eSRod Evans * added to all address values defined within the object. Otherwise, if 15508278a5eSRod Evans * this is an executable, all object addresses are used as is. 15608278a5eSRod Evans */ 15708278a5eSRod Evans if (ehdr->e_type == ET_EXEC) 15808278a5eSRod Evans base = 0; 15908278a5eSRod Evans else 16008278a5eSRod Evans base = (Addr)ehdr; 16108278a5eSRod Evans 16256deab07SRod Evans /* LINTED */ 16356deab07SRod Evans phdr = (Phdr *)((char *)ehdr + ehdr->e_phoff); 16456deab07SRod Evans for (cnt = 0; cnt < ehdr->e_phnum; cnt++, phdr++) { 16508278a5eSRod Evans if (phdr->p_type == PT_DYNAMIC) { 16608278a5eSRod Evans /* LINTED */ 16708278a5eSRod Evans dyn = (Dyn *)((uintptr_t)phdr->p_vaddr + base); 168f441771bSRod Evans dyncnt = phdr->p_filesz / sizeof (Dyn); 16908278a5eSRod Evans } else if (phdr->p_type == PT_SUNWCAP) { 17008278a5eSRod Evans /* LINTED */ 17108278a5eSRod Evans cap = (Cap *)((uintptr_t)phdr->p_vaddr + base); 17208278a5eSRod Evans } 17308278a5eSRod Evans } 17456deab07SRod Evans 17508278a5eSRod Evans if (cap) { 17608278a5eSRod Evans /* 17708278a5eSRod Evans * From the .dynamic section, determine the associated string 17808278a5eSRod Evans * table. Required for CA_SUNW_MACH and CA_SUNW_PLAT 17908278a5eSRod Evans * processing. 18008278a5eSRod Evans */ 181f441771bSRod Evans while (dyn && dyncnt) { 18208278a5eSRod Evans if (dyn->d_tag == DT_NULL) { 18308278a5eSRod Evans break; 18408278a5eSRod Evans } else if (dyn->d_tag == DT_STRTAB) { 18508278a5eSRod Evans str = (char *)(dyn->d_un.d_ptr + base); 18608278a5eSRod Evans break; 18756deab07SRod Evans } 188f441771bSRod Evans dyn++, dyncnt--; 18956deab07SRod Evans } 19056deab07SRod Evans } 19108278a5eSRod Evans 19208278a5eSRod Evans /* 19308278a5eSRod Evans * Establish any alternative capabilities, and validate this object 19408278a5eSRod Evans * if it defines it's own capabilities information. 19508278a5eSRod Evans */ 19608278a5eSRod Evans return (cap_check_fdesc(fdp, cap, str, rej)); 1977c478bd9Sstevel@tonic-gate } 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate /* 2007c478bd9Sstevel@tonic-gate * Determine if we have been given an ELF file and if so determine if the file 2017c478bd9Sstevel@tonic-gate * is compatible. Returns 1 if true, else 0 and sets the reject descriptor 2027c478bd9Sstevel@tonic-gate * with associated error information. 2037c478bd9Sstevel@tonic-gate */ 20456deab07SRod Evans Fct * 20556deab07SRod Evans elf_verify(caddr_t addr, size_t size, Fdesc *fdp, const char *name, 20656deab07SRod Evans Rej_desc *rej) 2077c478bd9Sstevel@tonic-gate { 2087c478bd9Sstevel@tonic-gate Ehdr *ehdr; 20956deab07SRod Evans char *caddr = (char *)addr; 2107c478bd9Sstevel@tonic-gate 2117c478bd9Sstevel@tonic-gate /* 2127c478bd9Sstevel@tonic-gate * Determine if we're an elf file. If not simply return, we don't set 2137c478bd9Sstevel@tonic-gate * any rejection information as this test allows use to scroll through 2147c478bd9Sstevel@tonic-gate * the objects we support (ELF, AOUT). 2157c478bd9Sstevel@tonic-gate */ 21656deab07SRod Evans if (size < sizeof (Ehdr) || 21756deab07SRod Evans caddr[EI_MAG0] != ELFMAG0 || 21856deab07SRod Evans caddr[EI_MAG1] != ELFMAG1 || 21956deab07SRod Evans caddr[EI_MAG2] != ELFMAG2 || 22056deab07SRod Evans caddr[EI_MAG3] != ELFMAG3) { 22156deab07SRod Evans return (NULL); 2227c478bd9Sstevel@tonic-gate } 2237c478bd9Sstevel@tonic-gate 2247c478bd9Sstevel@tonic-gate /* 2257c478bd9Sstevel@tonic-gate * Check class and encoding. 2267c478bd9Sstevel@tonic-gate */ 2277c478bd9Sstevel@tonic-gate /* LINTED */ 22856deab07SRod Evans ehdr = (Ehdr *)addr; 2297c478bd9Sstevel@tonic-gate if (ehdr->e_ident[EI_CLASS] != M_CLASS) { 2307c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_CLASS; 2317c478bd9Sstevel@tonic-gate rej->rej_info = (uint_t)ehdr->e_ident[EI_CLASS]; 23256deab07SRod Evans return (NULL); 2337c478bd9Sstevel@tonic-gate } 2347c478bd9Sstevel@tonic-gate if (ehdr->e_ident[EI_DATA] != M_DATA) { 2357c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_DATA; 2367c478bd9Sstevel@tonic-gate rej->rej_info = (uint_t)ehdr->e_ident[EI_DATA]; 23756deab07SRod Evans return (NULL); 2387c478bd9Sstevel@tonic-gate } 2397c478bd9Sstevel@tonic-gate if ((ehdr->e_type != ET_REL) && (ehdr->e_type != ET_EXEC) && 2407c478bd9Sstevel@tonic-gate (ehdr->e_type != ET_DYN)) { 2417c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_TYPE; 2427c478bd9Sstevel@tonic-gate rej->rej_info = (uint_t)ehdr->e_type; 24356deab07SRod Evans return (NULL); 2447c478bd9Sstevel@tonic-gate } 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate /* 24756deab07SRod Evans * Verify ELF version. 2487c478bd9Sstevel@tonic-gate */ 2497c478bd9Sstevel@tonic-gate if (ehdr->e_version > EV_CURRENT) { 2507c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_VERSION; 2517c478bd9Sstevel@tonic-gate rej->rej_info = (uint_t)ehdr->e_version; 25256deab07SRod Evans return (NULL); 2537c478bd9Sstevel@tonic-gate } 25456deab07SRod Evans 25556deab07SRod Evans /* 25656deab07SRod Evans * Verify machine specific flags. 25756deab07SRod Evans */ 25856deab07SRod Evans if (elf_mach_flags_check(rej, ehdr) == 0) 25956deab07SRod Evans return (NULL); 26056deab07SRod Evans 26156deab07SRod Evans /* 26208278a5eSRod Evans * Verify any capability requirements. Note, if this object is a shared 26308278a5eSRod Evans * object that is explicitly defined on the ldd(1) command line, and it 26408278a5eSRod Evans * contains an incompatible capabilities requirement, then inform the 26508278a5eSRod Evans * user, but continue processing. 26656deab07SRod Evans */ 26756deab07SRod Evans if (elf_cap_check(fdp, ehdr, rej) == 0) { 26856deab07SRod Evans Rt_map *lmp = lml_main.lm_head; 26956deab07SRod Evans 270dde769a2SRod Evans if ((lml_main.lm_flags & LML_FLG_TRC_LDDSTUB) && lmp && 271dde769a2SRod Evans (FLAGS1(lmp) & FL1_RT_LDDSTUB) && (NEXT(lmp) == NULL)) { 27208278a5eSRod Evans /* LINTED */ 27308278a5eSRod Evans (void) printf(MSG_INTL(ldd_warn[rej->rej_type]), name, 27408278a5eSRod Evans rej->rej_str); 27556deab07SRod Evans return (&elf_fct); 27656deab07SRod Evans } 27756deab07SRod Evans return (NULL); 27856deab07SRod Evans } 27956deab07SRod Evans return (&elf_fct); 2807c478bd9Sstevel@tonic-gate } 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate /* 2837c478bd9Sstevel@tonic-gate * The runtime linker employs lazy loading to provide the libraries needed for 2847c478bd9Sstevel@tonic-gate * debugging, preloading .o's and dldump(). As these are seldom used, the 2857c478bd9Sstevel@tonic-gate * standard startup of ld.so.1 doesn't initialize all the information necessary 2867c478bd9Sstevel@tonic-gate * to perform plt relocation on ld.so.1's link-map. The first time lazy loading 2877c478bd9Sstevel@tonic-gate * is called we get here to perform these initializations: 2887c478bd9Sstevel@tonic-gate * 289f441771bSRod Evans * - elf_needed() is called to establish any ld.so.1 dependencies. These 290f441771bSRod Evans * dependencies should all be lazy loaded, so this routine is typically a 29167d74cc3SToomas Soome * no-op. However, we call elf_needed() for completeness, in case any 292f441771bSRod Evans * NEEDED initialization is required. 2937c478bd9Sstevel@tonic-gate * 2942017c965SRod Evans * - For intel, ld.so.1's JMPSLOT relocations need relative updates. These 2957c478bd9Sstevel@tonic-gate * are by default skipped thus delaying all relative relocation processing 29667d74cc3SToomas Soome * on every invocation of ld.so.1. 2977c478bd9Sstevel@tonic-gate */ 2987c478bd9Sstevel@tonic-gate int 2997c478bd9Sstevel@tonic-gate elf_rtld_load() 3007c478bd9Sstevel@tonic-gate { 3017c478bd9Sstevel@tonic-gate Lm_list *lml = &lml_rtld; 3027c478bd9Sstevel@tonic-gate Rt_map *lmp = lml->lm_head; 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_PLTREL) 3057c478bd9Sstevel@tonic-gate return (1); 3067c478bd9Sstevel@tonic-gate 3079aa23310Srie if (elf_needed(lml, ALIST_OFF_DATA, lmp, NULL) == 0) 3087c478bd9Sstevel@tonic-gate return (0); 3097c478bd9Sstevel@tonic-gate 31002ca3e02Srie #if defined(__i386) 3117c478bd9Sstevel@tonic-gate /* 3127c478bd9Sstevel@tonic-gate * This is a kludge to give ld.so.1 a performance benefit on i386. 3137c478bd9Sstevel@tonic-gate * It's based around two factors. 3147c478bd9Sstevel@tonic-gate * 3152017c965SRod Evans * - JMPSLOT relocations (PLT's) actually need a relative relocation 3167c478bd9Sstevel@tonic-gate * applied to the GOT entry so that they can find PLT0. 3177c478bd9Sstevel@tonic-gate * 3182017c965SRod Evans * - ld.so.1 does not exercise *any* PLT's before it has made a call 3197c478bd9Sstevel@tonic-gate * to elf_lazy_load(). This is because all dynamic dependencies 32067d74cc3SToomas Soome * are recorded as lazy dependencies. 3217c478bd9Sstevel@tonic-gate */ 32256deab07SRod Evans (void) elf_reloc_relative_count((ulong_t)JMPREL(lmp), 3237c478bd9Sstevel@tonic-gate (ulong_t)(PLTRELSZ(lmp) / RELENT(lmp)), (ulong_t)RELENT(lmp), 324f441771bSRod Evans (ulong_t)ADDR(lmp), lmp, NULL, 0); 3257c478bd9Sstevel@tonic-gate #endif 3267c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_PLTREL; 3277c478bd9Sstevel@tonic-gate return (1); 3287c478bd9Sstevel@tonic-gate } 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate /* 3317c478bd9Sstevel@tonic-gate * Lazy load an object. 3327c478bd9Sstevel@tonic-gate */ 3337c478bd9Sstevel@tonic-gate Rt_map * 3349aa23310Srie elf_lazy_load(Rt_map *clmp, Slookup *slp, uint_t ndx, const char *sym, 3352017c965SRod Evans uint_t flags, Grp_hdl **hdl, int *in_nfavl) 3367c478bd9Sstevel@tonic-gate { 33756deab07SRod Evans Alist *palp = NULL; 338dde769a2SRod Evans Rt_map *nlmp; 33975e7992aSrie Dyninfo *dip = &DYNINFO(clmp)[ndx], *pdip; 3407c478bd9Sstevel@tonic-gate const char *name; 3417c478bd9Sstevel@tonic-gate Lm_list *lml = LIST(clmp); 3427c478bd9Sstevel@tonic-gate Aliste lmco; 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate /* 345f441771bSRod Evans * If this dependency should be ignored, or has already been processed, 346f441771bSRod Evans * we're done. 3477c478bd9Sstevel@tonic-gate */ 34856deab07SRod Evans if (((nlmp = (Rt_map *)dip->di_info) != NULL) || 349f441771bSRod Evans (dip->di_flags & (FLG_DI_IGNORE | FLG_DI_LDD_DONE))) 3507c478bd9Sstevel@tonic-gate return (nlmp); 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate /* 35375e7992aSrie * If we're running under ldd(1), indicate that this dependency has been 35475e7992aSrie * processed (see test above). It doesn't matter whether the object is 35575e7992aSrie * successfully loaded or not, this flag simply ensures that we don't 35675e7992aSrie * repeatedly attempt to load an object that has already failed to load. 35775e7992aSrie * To do so would create multiple failure diagnostics for the same 35875e7992aSrie * object under ldd(1). 35975e7992aSrie */ 36075e7992aSrie if (lml->lm_flags & LML_FLG_TRC_ENABLE) 36175e7992aSrie dip->di_flags |= FLG_DI_LDD_DONE; 36275e7992aSrie 36375e7992aSrie /* 36475e7992aSrie * Determine the initial dependency name. 3657c478bd9Sstevel@tonic-gate */ 366f441771bSRod Evans name = dip->di_name; 3675aefb655Srie DBG_CALL(Dbg_file_lazyload(clmp, name, sym)); 3687c478bd9Sstevel@tonic-gate 36975e7992aSrie /* 37075e7992aSrie * If this object needs to establish its own group, make sure a handle 37175e7992aSrie * is created. 37275e7992aSrie */ 3737c478bd9Sstevel@tonic-gate if (dip->di_flags & FLG_DI_GROUP) 3742017c965SRod Evans flags |= (FLG_RT_SETGROUP | FLG_RT_PUBHDL); 3757c478bd9Sstevel@tonic-gate 37675e7992aSrie /* 37775e7992aSrie * Lazy dependencies are identified as DT_NEEDED entries with a 37875e7992aSrie * DF_P1_LAZYLOAD flag in the previous DT_POSFLAG_1 element. The 37975e7992aSrie * dynamic information element that corresponds to the DT_POSFLAG_1 38075e7992aSrie * entry is free, and thus used to store the present entrance 38175e7992aSrie * identifier. This identifier is used to prevent multiple attempts to 38275e7992aSrie * load a failed lazy loadable dependency within the same runtime linker 38375e7992aSrie * operation. However, future attempts to reload this dependency are 38475e7992aSrie * still possible. 38575e7992aSrie */ 38675e7992aSrie if (ndx && (pdip = dip - 1) && (pdip->di_flags & FLG_DI_POSFLAG1)) 38775e7992aSrie pdip->di_info = (void *)slp->sl_id; 38875e7992aSrie 3897c478bd9Sstevel@tonic-gate /* 3907c478bd9Sstevel@tonic-gate * Expand the requested name if necessary. 3917c478bd9Sstevel@tonic-gate */ 39256deab07SRod Evans if (elf_fix_name(name, clmp, &palp, AL_CNT_NEEDED, 0) == 0) 39356deab07SRod Evans return (NULL); 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate /* 396dde769a2SRod Evans * Establish a link-map control list for this request. 3977c478bd9Sstevel@tonic-gate */ 39867d74cc3SToomas Soome if ((lmco = create_cntl(lml, 0)) == 0) { 3992020b2b6SRod Evans remove_alist(&palp, 1); 400dde769a2SRod Evans return (NULL); 401dde769a2SRod Evans } 4027c478bd9Sstevel@tonic-gate 4037c478bd9Sstevel@tonic-gate /* 4047c478bd9Sstevel@tonic-gate * Load the associated object. 4057c478bd9Sstevel@tonic-gate */ 4067c478bd9Sstevel@tonic-gate dip->di_info = nlmp = 4072017c965SRod Evans load_one(lml, lmco, palp, clmp, MODE(clmp), flags, hdl, in_nfavl); 4087c478bd9Sstevel@tonic-gate 4097c478bd9Sstevel@tonic-gate /* 4107c478bd9Sstevel@tonic-gate * Remove any expanded pathname infrastructure. Reduce the pending lazy 4117c478bd9Sstevel@tonic-gate * dependency count of the caller, together with the link-map lists 4127c478bd9Sstevel@tonic-gate * count of objects that still have lazy dependencies pending. 4137c478bd9Sstevel@tonic-gate */ 4142020b2b6SRod Evans remove_alist(&palp, 1); 4157c478bd9Sstevel@tonic-gate if (--LAZY(clmp) == 0) 4167c478bd9Sstevel@tonic-gate LIST(clmp)->lm_lazy--; 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate /* 41902ca3e02Srie * Finish processing the objects associated with this request, and 42002ca3e02Srie * create an association between the caller and this dependency. 4217c478bd9Sstevel@tonic-gate */ 42275e7992aSrie if (nlmp && ((bind_one(clmp, nlmp, BND_NEEDED) == 0) || 4232020b2b6SRod Evans ((nlmp = analyze_lmc(lml, lmco, nlmp, clmp, in_nfavl)) == NULL) || 4249aa23310Srie (relocate_lmc(lml, lmco, clmp, nlmp, in_nfavl) == 0))) 42556deab07SRod Evans dip->di_info = nlmp = NULL; 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate /* 42802ca3e02Srie * If this lazyload has failed, and we've created a new link-map 42902ca3e02Srie * control list to which this request has added objects, then remove 43002ca3e02Srie * all the objects that have been associated to this request. 4317c478bd9Sstevel@tonic-gate */ 432481bba9eSRod Evans if ((nlmp == NULL) && (lmco != ALIST_OFF_DATA)) 433481bba9eSRod Evans remove_lmc(lml, clmp, lmco, name); 4347c478bd9Sstevel@tonic-gate 4357c478bd9Sstevel@tonic-gate /* 436dde769a2SRod Evans * Remove any temporary link-map control list. 4377c478bd9Sstevel@tonic-gate */ 438481bba9eSRod Evans if (lmco != ALIST_OFF_DATA) 4397c478bd9Sstevel@tonic-gate remove_cntl(lml, lmco); 4407c478bd9Sstevel@tonic-gate 44175e7992aSrie /* 44275e7992aSrie * If this lazy loading failed, record the fact, and bump the lazy 44375e7992aSrie * counts. 44475e7992aSrie */ 44556deab07SRod Evans if (nlmp == NULL) { 44675e7992aSrie dip->di_flags |= FLG_DI_LAZYFAIL; 44775e7992aSrie if (LAZY(clmp)++ == 0) 44875e7992aSrie LIST(clmp)->lm_lazy++; 44975e7992aSrie } 45075e7992aSrie 4517c478bd9Sstevel@tonic-gate return (nlmp); 4527c478bd9Sstevel@tonic-gate } 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate /* 4557c478bd9Sstevel@tonic-gate * Return the entry point of the ELF executable. 4567c478bd9Sstevel@tonic-gate */ 45756deab07SRod Evans static Addr 45856deab07SRod Evans elf_entry_point(void) 4597c478bd9Sstevel@tonic-gate { 46056deab07SRod Evans Rt_map *lmp = lml_main.lm_head; 46156deab07SRod Evans Ehdr *ehdr = (Ehdr *)ADDR(lmp); 46256deab07SRod Evans Addr addr = (Addr)(ehdr->e_entry); 4637c478bd9Sstevel@tonic-gate 46456deab07SRod Evans if ((FLAGS(lmp) & FLG_RT_FIXED) == 0) 46556deab07SRod Evans addr += ADDR(lmp); 4667c478bd9Sstevel@tonic-gate 46756deab07SRod Evans return (addr); 4687c478bd9Sstevel@tonic-gate } 4697c478bd9Sstevel@tonic-gate 4707c478bd9Sstevel@tonic-gate /* 4717c478bd9Sstevel@tonic-gate * Determine if a dependency requires a particular version and if so verify 4727c478bd9Sstevel@tonic-gate * that the version exists in the dependency. 4737c478bd9Sstevel@tonic-gate */ 47456deab07SRod Evans int 4757c478bd9Sstevel@tonic-gate elf_verify_vers(const char *name, Rt_map *clmp, Rt_map *nlmp) 4767c478bd9Sstevel@tonic-gate { 4777c478bd9Sstevel@tonic-gate Verneed *vnd = VERNEED(clmp); 4787c478bd9Sstevel@tonic-gate int _num, num = VERNEEDNUM(clmp); 4797c478bd9Sstevel@tonic-gate char *cstrs = (char *)STRTAB(clmp); 4807c478bd9Sstevel@tonic-gate Lm_list *lml = LIST(clmp); 4817c478bd9Sstevel@tonic-gate 4827c478bd9Sstevel@tonic-gate /* 4837c478bd9Sstevel@tonic-gate * Traverse the callers version needed information and determine if any 4847c478bd9Sstevel@tonic-gate * specific versions are required from the dependency. 4857c478bd9Sstevel@tonic-gate */ 4865aefb655Srie DBG_CALL(Dbg_ver_need_title(LIST(clmp), NAME(clmp))); 4877c478bd9Sstevel@tonic-gate for (_num = 1; _num <= num; _num++, 4887c478bd9Sstevel@tonic-gate vnd = (Verneed *)((Xword)vnd + vnd->vn_next)) { 4897c478bd9Sstevel@tonic-gate Half cnt = vnd->vn_cnt; 4907c478bd9Sstevel@tonic-gate Vernaux *vnap; 4917c478bd9Sstevel@tonic-gate char *nstrs, *need; 4927c478bd9Sstevel@tonic-gate 4937c478bd9Sstevel@tonic-gate /* 4947c478bd9Sstevel@tonic-gate * Determine if a needed entry matches this dependency. 4957c478bd9Sstevel@tonic-gate */ 4967c478bd9Sstevel@tonic-gate need = (char *)(cstrs + vnd->vn_file); 4977c478bd9Sstevel@tonic-gate if (strcmp(name, need) != 0) 4987c478bd9Sstevel@tonic-gate continue; 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_TRC_VERBOSE) && 5017c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0)) 5027c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_VER_FIND), name); 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate /* 5057c478bd9Sstevel@tonic-gate * Validate that each version required actually exists in the 5067c478bd9Sstevel@tonic-gate * dependency. 5077c478bd9Sstevel@tonic-gate */ 5087c478bd9Sstevel@tonic-gate nstrs = (char *)STRTAB(nlmp); 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate for (vnap = (Vernaux *)((Xword)vnd + vnd->vn_aux); cnt; 5117c478bd9Sstevel@tonic-gate cnt--, vnap = (Vernaux *)((Xword)vnap + vnap->vna_next)) { 5127c478bd9Sstevel@tonic-gate char *version, *define; 5137c478bd9Sstevel@tonic-gate Verdef *vdf = VERDEF(nlmp); 5147c478bd9Sstevel@tonic-gate ulong_t _num, num = VERDEFNUM(nlmp); 5157c478bd9Sstevel@tonic-gate int found = 0; 5167c478bd9Sstevel@tonic-gate 517090a8d9eSAli Bahrami /* 518090a8d9eSAli Bahrami * Skip validation of versions that are marked 519090a8d9eSAli Bahrami * INFO. This optimization is used for versions 520090a8d9eSAli Bahrami * that are inherited by another version. Verification 521090a8d9eSAli Bahrami * of the inheriting version is sufficient. 522090a8d9eSAli Bahrami * 523090a8d9eSAli Bahrami * Such versions are recorded in the object for the 524090a8d9eSAli Bahrami * benefit of VERSYM entries that refer to them. This 52508278a5eSRod Evans * provides a purely diagnostic benefit. 526090a8d9eSAli Bahrami */ 527090a8d9eSAli Bahrami if (vnap->vna_flags & VER_FLG_INFO) 528090a8d9eSAli Bahrami continue; 529090a8d9eSAli Bahrami 5307c478bd9Sstevel@tonic-gate version = (char *)(cstrs + vnap->vna_name); 5315aefb655Srie DBG_CALL(Dbg_ver_need_entry(lml, 0, need, version)); 5327c478bd9Sstevel@tonic-gate 5337c478bd9Sstevel@tonic-gate for (_num = 1; _num <= num; _num++, 5347c478bd9Sstevel@tonic-gate vdf = (Verdef *)((Xword)vdf + vdf->vd_next)) { 5357c478bd9Sstevel@tonic-gate Verdaux *vdap; 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate if (vnap->vna_hash != vdf->vd_hash) 5387c478bd9Sstevel@tonic-gate continue; 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate vdap = (Verdaux *)((Xword)vdf + vdf->vd_aux); 5417c478bd9Sstevel@tonic-gate define = (char *)(nstrs + vdap->vda_name); 5427c478bd9Sstevel@tonic-gate if (strcmp(version, define) != 0) 5437c478bd9Sstevel@tonic-gate continue; 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate found++; 5467c478bd9Sstevel@tonic-gate break; 5477c478bd9Sstevel@tonic-gate } 5487c478bd9Sstevel@tonic-gate 5497c478bd9Sstevel@tonic-gate /* 5507c478bd9Sstevel@tonic-gate * If we're being traced print out any matched version 5517c478bd9Sstevel@tonic-gate * when the verbose (-v) option is in effect. Always 5527c478bd9Sstevel@tonic-gate * print any unmatched versions. 5537c478bd9Sstevel@tonic-gate */ 5547c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) { 555a953e2b1Srie /* BEGIN CSTYLED */ 5567c478bd9Sstevel@tonic-gate if (found) { 5577c478bd9Sstevel@tonic-gate if (!(lml->lm_flags & LML_FLG_TRC_VERBOSE)) 5587c478bd9Sstevel@tonic-gate continue; 5597c478bd9Sstevel@tonic-gate 5607c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_VER_FOUND), 5617c478bd9Sstevel@tonic-gate need, version, NAME(nlmp)); 5627c478bd9Sstevel@tonic-gate } else { 5637c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_SILENCERR) 5647c478bd9Sstevel@tonic-gate continue; 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_VER_NFOUND), 5677c478bd9Sstevel@tonic-gate need, version); 5687c478bd9Sstevel@tonic-gate } 569a953e2b1Srie /* END CSTYLED */ 5707c478bd9Sstevel@tonic-gate continue; 5717c478bd9Sstevel@tonic-gate } 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate /* 5747c478bd9Sstevel@tonic-gate * If the version hasn't been found then this is a 5757c478bd9Sstevel@tonic-gate * candidate for a fatal error condition. Weak 5767c478bd9Sstevel@tonic-gate * version definition requirements are silently 5777c478bd9Sstevel@tonic-gate * ignored. Also, if the image inspected for a version 5787c478bd9Sstevel@tonic-gate * definition has no versioning recorded at all then 5797c478bd9Sstevel@tonic-gate * silently ignore this (this provides better backward 5807c478bd9Sstevel@tonic-gate * compatibility to old images created prior to 5817c478bd9Sstevel@tonic-gate * versioning being available). Both of these skipped 5827c478bd9Sstevel@tonic-gate * diagnostics are available under tracing (see above). 5837c478bd9Sstevel@tonic-gate */ 5847c478bd9Sstevel@tonic-gate if ((found == 0) && (num != 0) && 5857c478bd9Sstevel@tonic-gate (!(vnap->vna_flags & VER_FLG_WEAK))) { 5865aefb655Srie eprintf(lml, ERR_FATAL, 5875aefb655Srie MSG_INTL(MSG_VER_NFOUND), need, version, 5885aefb655Srie NAME(clmp)); 5897c478bd9Sstevel@tonic-gate return (0); 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate } 5927c478bd9Sstevel@tonic-gate } 59320272c2eSAli Bahrami DBG_CALL(Dbg_ver_need_done(lml)); 5947c478bd9Sstevel@tonic-gate return (1); 5957c478bd9Sstevel@tonic-gate } 5967c478bd9Sstevel@tonic-gate 5977c478bd9Sstevel@tonic-gate /* 5987c478bd9Sstevel@tonic-gate * Search through the dynamic section for DT_NEEDED entries and perform one 5997c478bd9Sstevel@tonic-gate * of two functions. If only the first argument is specified then load the 6007c478bd9Sstevel@tonic-gate * defined shared object, otherwise add the link map representing the defined 6017c478bd9Sstevel@tonic-gate * link map the the dlopen list. 6027c478bd9Sstevel@tonic-gate */ 6037c478bd9Sstevel@tonic-gate static int 6049aa23310Srie elf_needed(Lm_list *lml, Aliste lmco, Rt_map *clmp, int *in_nfavl) 6057c478bd9Sstevel@tonic-gate { 60656deab07SRod Evans Alist *palp = NULL; 607f441771bSRod Evans Dyn *dyn; 608f441771bSRod Evans Dyninfo *dip; 6097c478bd9Sstevel@tonic-gate Word lmflags = lml->lm_flags; 6107c478bd9Sstevel@tonic-gate 6117c478bd9Sstevel@tonic-gate /* 612f441771bSRod Evans * A DYNINFO() structure is created during link-map generation that 613f441771bSRod Evans * parallels the DYN() information, and defines any flags that 614f441771bSRod Evans * influence a dependencies loading. 6157c478bd9Sstevel@tonic-gate */ 616f441771bSRod Evans for (dyn = DYN(clmp), dip = DYNINFO(clmp); 617f441771bSRod Evans !(dip->di_flags & FLG_DI_IGNORE); dyn++, dip++) { 618f441771bSRod Evans uint_t flags = 0, silent = 0; 619f441771bSRod Evans const char *name = dip->di_name; 620f441771bSRod Evans Rt_map *nlmp = NULL; 6217c478bd9Sstevel@tonic-gate 622f441771bSRod Evans if ((dip->di_flags & FLG_DI_NEEDED) == 0) 623f441771bSRod Evans continue; 6247c478bd9Sstevel@tonic-gate 625f441771bSRod Evans /* 626f441771bSRod Evans * Skip any deferred dependencies, unless ldd(1) has forced 627f441771bSRod Evans * their processing. By default, deferred dependencies are 628f441771bSRod Evans * only processed when an explicit binding to an individual 629f441771bSRod Evans * deferred reference is made. 630f441771bSRod Evans */ 631f441771bSRod Evans if ((dip->di_flags & FLG_DI_DEFERRED) && 632f441771bSRod Evans ((rtld_flags & RT_FL_DEFERRED) == 0)) 6337c478bd9Sstevel@tonic-gate continue; 6347c478bd9Sstevel@tonic-gate 635f441771bSRod Evans /* 636f441771bSRod Evans * NOTE, libc.so.1 can't be lazy loaded. Although a lazy 637f441771bSRod Evans * position flag won't be produced when a RTLDINFO .dynamic 638f441771bSRod Evans * entry is found (introduced with the UPM in Solaris 10), it 639f441771bSRod Evans * was possible to mark libc for lazy loading on previous 640f441771bSRod Evans * releases. To reduce the overhead of testing for this 641f441771bSRod Evans * occurrence, only carry out this check for the first object 642f441771bSRod Evans * on the link-map list (there aren't many applications built 643f441771bSRod Evans * without libc). 644f441771bSRod Evans */ 645f441771bSRod Evans if ((dip->di_flags & FLG_DI_LAZY) && (lml->lm_head == clmp) && 646f441771bSRod Evans (strcmp(name, MSG_ORIG(MSG_FIL_LIBC)) == 0)) 647f441771bSRod Evans dip->di_flags &= ~FLG_DI_LAZY; 6487c478bd9Sstevel@tonic-gate 649f441771bSRod Evans /* 650f441771bSRod Evans * Don't bring in lazy loaded objects yet unless we've been 651f441771bSRod Evans * asked to attempt to load all available objects (crle(1) sets 652f441771bSRod Evans * LD_FLAGS=loadavail). Even under RTLD_NOW we don't process 653f441771bSRod Evans * this - RTLD_NOW will cause relocation processing which in 654f441771bSRod Evans * turn might trigger lazy loading, but its possible that the 655f441771bSRod Evans * object has a lazy loaded file with no bindings (i.e., it 656f441771bSRod Evans * should never have been a dependency in the first place). 657f441771bSRod Evans */ 658f441771bSRod Evans if (dip->di_flags & FLG_DI_LAZY) { 659f441771bSRod Evans if ((lmflags & LML_FLG_LOADAVAIL) == 0) { 660f441771bSRod Evans LAZY(clmp)++; 661f441771bSRod Evans continue; 662f441771bSRod Evans } 6637c478bd9Sstevel@tonic-gate 6647c478bd9Sstevel@tonic-gate /* 665f441771bSRod Evans * Silence any error messages - see description under 666f441771bSRod Evans * elf_lookup_filtee(). 6677c478bd9Sstevel@tonic-gate */ 668f441771bSRod Evans if ((rtld_flags & RT_FL_SILENCERR) == 0) { 669f441771bSRod Evans rtld_flags |= RT_FL_SILENCERR; 670f441771bSRod Evans silent = 1; 6717c478bd9Sstevel@tonic-gate } 6727c478bd9Sstevel@tonic-gate } 6737c478bd9Sstevel@tonic-gate 6745aefb655Srie DBG_CALL(Dbg_file_needed(clmp, name)); 67575e7992aSrie 67675e7992aSrie /* 67775e7992aSrie * If we're running under ldd(1), indicate that this dependency 67875e7992aSrie * has been processed. It doesn't matter whether the object is 67975e7992aSrie * successfully loaded or not, this flag simply ensures that we 68075e7992aSrie * don't repeatedly attempt to load an object that has already 68175e7992aSrie * failed to load. To do so would create multiple failure 68275e7992aSrie * diagnostics for the same object under ldd(1). 68375e7992aSrie */ 6847c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) 68575e7992aSrie dip->di_flags |= FLG_DI_LDD_DONE; 6867c478bd9Sstevel@tonic-gate 687f441771bSRod Evans /* 688f441771bSRod Evans * Identify any group permission requirements. 689f441771bSRod Evans */ 690f441771bSRod Evans if (dip->di_flags & FLG_DI_GROUP) 691f441771bSRod Evans flags = (FLG_RT_SETGROUP | FLG_RT_PUBHDL); 692f441771bSRod Evans 6937c478bd9Sstevel@tonic-gate /* 6947c478bd9Sstevel@tonic-gate * Establish the objects name, load it and establish a binding 6957c478bd9Sstevel@tonic-gate * with the caller. 6967c478bd9Sstevel@tonic-gate */ 69756deab07SRod Evans if ((elf_fix_name(name, clmp, &palp, AL_CNT_NEEDED, 0) == 0) || 69856deab07SRod Evans ((nlmp = load_one(lml, lmco, palp, clmp, MODE(clmp), 69956deab07SRod Evans flags, 0, in_nfavl)) == NULL) || 70056deab07SRod Evans (bind_one(clmp, nlmp, BND_NEEDED) == 0)) 701481bba9eSRod Evans nlmp = NULL; 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate /* 7047c478bd9Sstevel@tonic-gate * Clean up any infrastructure, including the removal of the 7057c478bd9Sstevel@tonic-gate * error suppression state, if it had been previously set in 7067c478bd9Sstevel@tonic-gate * this routine. 7077c478bd9Sstevel@tonic-gate */ 7082020b2b6SRod Evans remove_alist(&palp, 0); 70956deab07SRod Evans 7107c478bd9Sstevel@tonic-gate if (silent) 7117c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_SILENCERR; 71275e7992aSrie 713481bba9eSRod Evans if ((dip->di_info = (void *)nlmp) == NULL) { 7147c478bd9Sstevel@tonic-gate /* 7157c478bd9Sstevel@tonic-gate * If the object could not be mapped, continue if error 7167c478bd9Sstevel@tonic-gate * suppression is established or we're here with ldd(1). 7177c478bd9Sstevel@tonic-gate */ 7187c478bd9Sstevel@tonic-gate if ((MODE(clmp) & RTLD_CONFGEN) || (lmflags & 7197c478bd9Sstevel@tonic-gate (LML_FLG_LOADAVAIL | LML_FLG_TRC_ENABLE))) 7207c478bd9Sstevel@tonic-gate continue; 72156deab07SRod Evans else { 7222020b2b6SRod Evans remove_alist(&palp, 1); 7237c478bd9Sstevel@tonic-gate return (0); 72456deab07SRod Evans } 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate if (LAZY(clmp)) 7297c478bd9Sstevel@tonic-gate lml->lm_lazy++; 7307c478bd9Sstevel@tonic-gate 7312020b2b6SRod Evans remove_alist(&palp, 1); 7327c478bd9Sstevel@tonic-gate return (1); 7337c478bd9Sstevel@tonic-gate } 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate /* 7367c478bd9Sstevel@tonic-gate * A null symbol interpretor. Used if a filter has no associated filtees. 7377c478bd9Sstevel@tonic-gate */ 7387c478bd9Sstevel@tonic-gate /* ARGSUSED0 */ 73908278a5eSRod Evans static int 74008278a5eSRod Evans elf_null_find_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl) 7417c478bd9Sstevel@tonic-gate { 74208278a5eSRod Evans return (0); 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate 7457c478bd9Sstevel@tonic-gate /* 7467c478bd9Sstevel@tonic-gate * Disable filtee use. 7477c478bd9Sstevel@tonic-gate */ 7487c478bd9Sstevel@tonic-gate static void 7499a411307Srie elf_disable_filtee(Rt_map *lmp, Dyninfo *dip) 7507c478bd9Sstevel@tonic-gate { 7517c478bd9Sstevel@tonic-gate if ((dip->di_flags & FLG_DI_SYMFLTR) == 0) { 7527c478bd9Sstevel@tonic-gate /* 75356deab07SRod Evans * If this is an object filter, null out the reference name. 7547c478bd9Sstevel@tonic-gate */ 7557c478bd9Sstevel@tonic-gate if (OBJFLTRNDX(lmp) != FLTR_DISABLED) { 75637ffaf83SRod Evans REFNAME(lmp) = NULL; 7577c478bd9Sstevel@tonic-gate OBJFLTRNDX(lmp) = FLTR_DISABLED; 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate /* 7607c478bd9Sstevel@tonic-gate * Indicate that this filtee is no longer available. 7617c478bd9Sstevel@tonic-gate */ 7627c478bd9Sstevel@tonic-gate if (dip->di_flags & FLG_DI_STDFLTR) 7637c478bd9Sstevel@tonic-gate SYMINTP(lmp) = elf_null_find_sym; 7647c478bd9Sstevel@tonic-gate 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate } else if (dip->di_flags & FLG_DI_STDFLTR) { 7677c478bd9Sstevel@tonic-gate /* 7687c478bd9Sstevel@tonic-gate * Indicate that this standard filtee is no longer available. 7697c478bd9Sstevel@tonic-gate */ 7707c478bd9Sstevel@tonic-gate if (SYMSFLTRCNT(lmp)) 7717c478bd9Sstevel@tonic-gate SYMSFLTRCNT(lmp)--; 7727c478bd9Sstevel@tonic-gate } else { 7737c478bd9Sstevel@tonic-gate /* 7747c478bd9Sstevel@tonic-gate * Indicate that this auxiliary filtee is no longer available. 7757c478bd9Sstevel@tonic-gate */ 7767c478bd9Sstevel@tonic-gate if (SYMAFLTRCNT(lmp)) 7777c478bd9Sstevel@tonic-gate SYMAFLTRCNT(lmp)--; 7787c478bd9Sstevel@tonic-gate } 7797c478bd9Sstevel@tonic-gate dip->di_flags &= ~MSK_DI_FILTER; 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate /* 7837c478bd9Sstevel@tonic-gate * Find symbol interpreter - filters. 7847c478bd9Sstevel@tonic-gate * This function is called when the symbols from a shared object should 7857c478bd9Sstevel@tonic-gate * be resolved from the shared objects filtees instead of from within itself. 7867c478bd9Sstevel@tonic-gate * 7877c478bd9Sstevel@tonic-gate * A symbol name of 0 is used to trigger filtee loading. 7887c478bd9Sstevel@tonic-gate */ 78908278a5eSRod Evans static int 79008278a5eSRod Evans _elf_lookup_filtee(Slookup *slp, Sresult *srp, uint_t *binfo, uint_t ndx, 7919aa23310Srie int *in_nfavl) 7927c478bd9Sstevel@tonic-gate { 7937c478bd9Sstevel@tonic-gate const char *name = slp->sl_name, *filtees; 7947c478bd9Sstevel@tonic-gate Rt_map *clmp = slp->sl_cmap; 7957c478bd9Sstevel@tonic-gate Rt_map *ilmp = slp->sl_imap; 79656deab07SRod Evans Pdesc *pdp; 7977c478bd9Sstevel@tonic-gate int any; 7987c478bd9Sstevel@tonic-gate Dyninfo *dip = &DYNINFO(ilmp)[ndx]; 7997c478bd9Sstevel@tonic-gate Lm_list *lml = LIST(ilmp); 80056deab07SRod Evans Aliste idx; 8017c478bd9Sstevel@tonic-gate 8027c478bd9Sstevel@tonic-gate /* 8037c478bd9Sstevel@tonic-gate * Indicate that the filter has been used. If a binding already exists 8047c478bd9Sstevel@tonic-gate * to the caller, indicate that this object is referenced. This insures 8057c478bd9Sstevel@tonic-gate * we don't generate false unreferenced diagnostics from ldd -u/U or 8067c478bd9Sstevel@tonic-gate * debugging. Don't create a binding regardless, as this filter may 8077c478bd9Sstevel@tonic-gate * have been dlopen()'ed. 8087c478bd9Sstevel@tonic-gate */ 8097c478bd9Sstevel@tonic-gate if (name && (ilmp != clmp)) { 8107c478bd9Sstevel@tonic-gate Word tracing = (LIST(clmp)->lm_flags & 8117c478bd9Sstevel@tonic-gate (LML_FLG_TRC_UNREF | LML_FLG_TRC_UNUSED)); 8127c478bd9Sstevel@tonic-gate 8135aefb655Srie if (tracing || DBG_ENABLED) { 81467d74cc3SToomas Soome Bnd_desc *bdp; 815cce0e03bSab Aliste idx; 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate FLAGS1(ilmp) |= FL1_RT_USED; 8187c478bd9Sstevel@tonic-gate 8195aefb655Srie if ((tracing & LML_FLG_TRC_UNREF) || DBG_ENABLED) { 820cce0e03bSab for (APLIST_TRAVERSE(CALLERS(ilmp), idx, bdp)) { 8217c478bd9Sstevel@tonic-gate if (bdp->b_caller == clmp) { 8227c478bd9Sstevel@tonic-gate bdp->b_flags |= BND_REFER; 8237c478bd9Sstevel@tonic-gate break; 8247c478bd9Sstevel@tonic-gate } 8257c478bd9Sstevel@tonic-gate } 8267c478bd9Sstevel@tonic-gate } 8277c478bd9Sstevel@tonic-gate } 8287c478bd9Sstevel@tonic-gate } 8297c478bd9Sstevel@tonic-gate 8307c478bd9Sstevel@tonic-gate /* 8317c478bd9Sstevel@tonic-gate * If this is the first call to process this filter, establish the 8327c478bd9Sstevel@tonic-gate * filtee list. If a configuration file exists, determine if any 8337c478bd9Sstevel@tonic-gate * filtee associations for this filter, and its filtee reference, are 8347c478bd9Sstevel@tonic-gate * defined. Otherwise, process the filtee reference. Any token 8357c478bd9Sstevel@tonic-gate * expansion is also completed at this point (i.e., $PLATFORM). 8367c478bd9Sstevel@tonic-gate */ 837f441771bSRod Evans filtees = dip->di_name; 838481bba9eSRod Evans if (dip->di_info == NULL) { 83908278a5eSRod Evans if (rtld_flags2 & RT_FL2_FLTCFG) { 84056deab07SRod Evans elf_config_flt(lml, PATHNAME(ilmp), filtees, 84156deab07SRod Evans (Alist **)&dip->di_info, AL_CNT_FILTEES); 84208278a5eSRod Evans } 843481bba9eSRod Evans if (dip->di_info == NULL) { 8445aefb655Srie DBG_CALL(Dbg_file_filter(lml, NAME(ilmp), filtees, 0)); 8457c478bd9Sstevel@tonic-gate if ((lml->lm_flags & 8467c478bd9Sstevel@tonic-gate (LML_FLG_TRC_VERBOSE | LML_FLG_TRC_SEARCH)) && 8477c478bd9Sstevel@tonic-gate ((FLAGS1(ilmp) & FL1_RT_LDDSTUB) == 0)) 8487c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_FIL_FILTER), 8497c478bd9Sstevel@tonic-gate NAME(ilmp), filtees); 8507c478bd9Sstevel@tonic-gate 85156deab07SRod Evans if (expand_paths(ilmp, filtees, (Alist **)&dip->di_info, 85256deab07SRod Evans AL_CNT_FILTEES, 0, 0) == 0) { 8537c478bd9Sstevel@tonic-gate elf_disable_filtee(ilmp, dip); 85408278a5eSRod Evans return (0); 8557c478bd9Sstevel@tonic-gate } 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate } 8587c478bd9Sstevel@tonic-gate 8597c478bd9Sstevel@tonic-gate /* 8607c478bd9Sstevel@tonic-gate * Traverse the filtee list, dlopen()'ing any objects specified and 8617c478bd9Sstevel@tonic-gate * using their group handle to lookup the symbol. 8627c478bd9Sstevel@tonic-gate */ 86356deab07SRod Evans any = 0; 86456deab07SRod Evans for (ALIST_TRAVERSE((Alist *)dip->di_info, idx, pdp)) { 8657c478bd9Sstevel@tonic-gate int mode; 8667c478bd9Sstevel@tonic-gate Grp_hdl *ghp; 867481bba9eSRod Evans Rt_map *nlmp = NULL; 8687c478bd9Sstevel@tonic-gate 86956deab07SRod Evans if (pdp->pd_plen == 0) 8707c478bd9Sstevel@tonic-gate continue; 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate /* 8737c478bd9Sstevel@tonic-gate * Establish the mode of the filtee from the filter. As filtees 8747c478bd9Sstevel@tonic-gate * are loaded via a dlopen(), make sure that RTLD_GROUP is set 8757c478bd9Sstevel@tonic-gate * and the filtees aren't global. It would be nice to have 8767c478bd9Sstevel@tonic-gate * RTLD_FIRST used here also, but as filters got out long before 8777c478bd9Sstevel@tonic-gate * RTLD_FIRST was introduced it's a little too late now. 8787c478bd9Sstevel@tonic-gate */ 8797c478bd9Sstevel@tonic-gate mode = MODE(ilmp) | RTLD_GROUP; 8807c478bd9Sstevel@tonic-gate mode &= ~RTLD_GLOBAL; 8817c478bd9Sstevel@tonic-gate 8827c478bd9Sstevel@tonic-gate /* 8837c478bd9Sstevel@tonic-gate * Insure that any auxiliary filter can locate symbols from its 8847c478bd9Sstevel@tonic-gate * caller. 8857c478bd9Sstevel@tonic-gate */ 8867c478bd9Sstevel@tonic-gate if (dip->di_flags & FLG_DI_AUXFLTR) 8877c478bd9Sstevel@tonic-gate mode |= RTLD_PARENT; 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate /* 89008278a5eSRod Evans * Process any capability directory. Establish a new link-map 89108278a5eSRod Evans * control list from which to analyze any newly added objects. 8927c478bd9Sstevel@tonic-gate */ 89308278a5eSRod Evans if ((pdp->pd_info == NULL) && (pdp->pd_flags & PD_TKN_CAP)) { 89456deab07SRod Evans const char *dir = pdp->pd_pname; 89556deab07SRod Evans Aliste lmco; 89611a2bb38Srie 897dde769a2SRod Evans /* 898dde769a2SRod Evans * Establish a link-map control list for this request. 899dde769a2SRod Evans */ 90067d74cc3SToomas Soome if ((lmco = create_cntl(lml, 0)) == 0) 90167d74cc3SToomas Soome return (0); 9027c478bd9Sstevel@tonic-gate 90356deab07SRod Evans /* 90408278a5eSRod Evans * Determine the capability filtees. If none can be 90508278a5eSRod Evans * found, provide suitable diagnostics. 90656deab07SRod Evans */ 90708278a5eSRod Evans DBG_CALL(Dbg_cap_filter(lml, dir, ilmp)); 90808278a5eSRod Evans if (cap_filtees((Alist **)&dip->di_info, idx, dir, 9092020b2b6SRod Evans lmco, ilmp, clmp, filtees, mode, 91008278a5eSRod Evans (FLG_RT_PUBHDL | FLG_RT_CAP), in_nfavl) == 0) { 91156deab07SRod Evans if ((lml->lm_flags & LML_FLG_TRC_ENABLE) && 91256deab07SRod Evans (dip->di_flags & FLG_DI_AUXFLTR) && 91356deab07SRod Evans (rtld_flags & RT_FL_WARNFLTR)) { 91456deab07SRod Evans (void) printf( 91508278a5eSRod Evans MSG_INTL(MSG_LDD_CAP_NFOUND), dir); 91656deab07SRod Evans } 91708278a5eSRod Evans DBG_CALL(Dbg_cap_filter(lml, dir, 0)); 91856deab07SRod Evans } 91956deab07SRod Evans 92056deab07SRod Evans /* 92108278a5eSRod Evans * Re-establish the originating path name descriptor, 92208278a5eSRod Evans * as the expansion of capabilities filtees may have 92308278a5eSRod Evans * re-allocated the controlling Alist. Mark this 92456deab07SRod Evans * original pathname descriptor as unused so that the 92556deab07SRod Evans * descriptor isn't revisited for processing. Any real 92608278a5eSRod Evans * capabilities filtees have been added as new pathname 92708278a5eSRod Evans * descriptors following this descriptor. 92856deab07SRod Evans */ 92956deab07SRod Evans pdp = alist_item((Alist *)dip->di_info, idx); 93008278a5eSRod Evans pdp->pd_flags &= ~PD_TKN_CAP; 93156deab07SRod Evans pdp->pd_plen = 0; 93211a2bb38Srie 93311a2bb38Srie /* 93408278a5eSRod Evans * Now that any capability objects have been processed, 93508278a5eSRod Evans * remove any temporary link-map control list. 93611a2bb38Srie */ 937481bba9eSRod Evans if (lmco != ALIST_OFF_DATA) 93811a2bb38Srie remove_cntl(lml, lmco); 9397c478bd9Sstevel@tonic-gate } 9407c478bd9Sstevel@tonic-gate 94156deab07SRod Evans if (pdp->pd_plen == 0) 9427c478bd9Sstevel@tonic-gate continue; 9437c478bd9Sstevel@tonic-gate 9447c478bd9Sstevel@tonic-gate /* 9457c478bd9Sstevel@tonic-gate * Process an individual filtee. 9467c478bd9Sstevel@tonic-gate */ 947481bba9eSRod Evans if (pdp->pd_info == NULL) { 94856deab07SRod Evans const char *filtee = pdp->pd_pname; 9497c478bd9Sstevel@tonic-gate int audit = 0; 9507c478bd9Sstevel@tonic-gate 9515aefb655Srie DBG_CALL(Dbg_file_filtee(lml, NAME(ilmp), filtee, 0)); 9527c478bd9Sstevel@tonic-gate 953481bba9eSRod Evans ghp = NULL; 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate /* 9567c478bd9Sstevel@tonic-gate * Determine if the reference link map is already 9577c478bd9Sstevel@tonic-gate * loaded. As an optimization compare the filtee with 9587c478bd9Sstevel@tonic-gate * our interpretor. The most common filter is 9597c478bd9Sstevel@tonic-gate * libdl.so.1, which is a filter on ld.so.1. 9607c478bd9Sstevel@tonic-gate */ 9617c478bd9Sstevel@tonic-gate #if defined(_ELF64) 9627c478bd9Sstevel@tonic-gate if (strcmp(filtee, MSG_ORIG(MSG_PTH_RTLD_64)) == 0) { 9637c478bd9Sstevel@tonic-gate #else 9647c478bd9Sstevel@tonic-gate if (strcmp(filtee, MSG_ORIG(MSG_PTH_RTLD)) == 0) { 9657c478bd9Sstevel@tonic-gate #endif 9662017c965SRod Evans uint_t hflags, rdflags, cdflags; 9672017c965SRod Evans 9682017c965SRod Evans /* 9692017c965SRod Evans * Establish any flags for the handle (Grp_hdl). 9702017c965SRod Evans * 9712017c965SRod Evans * - This is a special, public, ld.so.1 9722017c965SRod Evans * handle. 9732017c965SRod Evans * - Only the first object on this handle 9742017c965SRod Evans * can supply symbols. 9752017c965SRod Evans * - This handle provides a filtee. 9762017c965SRod Evans * 9772017c965SRod Evans * Essentially, this handle allows a caller to 9782017c965SRod Evans * reference the dl*() family of interfaces from 9792017c965SRod Evans * ld.so.1. 9802017c965SRod Evans */ 9812017c965SRod Evans hflags = (GPH_PUBLIC | GPH_LDSO | 9822017c965SRod Evans GPH_FIRST | GPH_FILTEE); 9832017c965SRod Evans 9842017c965SRod Evans /* 9852017c965SRod Evans * Establish the flags for the referenced 9862017c965SRod Evans * dependency descriptor (Grp_desc). 9872017c965SRod Evans * 9882017c965SRod Evans * - ld.so.1 is available for dlsym(). 9892017c965SRod Evans * - ld.so.1 is available to relocate 9902017c965SRod Evans * against. 9912017c965SRod Evans * - There's no need to add an dependencies 99267d74cc3SToomas Soome * to this handle. 9932017c965SRod Evans */ 9942017c965SRod Evans rdflags = (GPD_DLSYM | GPD_RELOC); 9952017c965SRod Evans 9967c478bd9Sstevel@tonic-gate /* 9972017c965SRod Evans * Establish the flags for this callers 9982017c965SRod Evans * dependency descriptor (Grp_desc). 9992017c965SRod Evans * 10002017c965SRod Evans * - The explicit creation of a handle 10012017c965SRod Evans * creates a descriptor for the referenced 10022017c965SRod Evans * object and the parent (caller). 10037c478bd9Sstevel@tonic-gate */ 10042017c965SRod Evans cdflags = GPD_PARENT; 10052017c965SRod Evans 10067c478bd9Sstevel@tonic-gate nlmp = lml_rtld.lm_head; 10077c478bd9Sstevel@tonic-gate if ((ghp = hdl_create(&lml_rtld, nlmp, ilmp, 10082017c965SRod Evans hflags, rdflags, cdflags)) == NULL) 1009481bba9eSRod Evans nlmp = NULL; 10107c478bd9Sstevel@tonic-gate 10117c478bd9Sstevel@tonic-gate /* 10127c478bd9Sstevel@tonic-gate * Establish the filter handle to prevent any 10137c478bd9Sstevel@tonic-gate * recursion. 10147c478bd9Sstevel@tonic-gate */ 10157c478bd9Sstevel@tonic-gate if (nlmp && ghp) 101656deab07SRod Evans pdp->pd_info = (void *)ghp; 10177c478bd9Sstevel@tonic-gate 10187c478bd9Sstevel@tonic-gate /* 10197c478bd9Sstevel@tonic-gate * Audit the filter/filtee established. Ignore 10207c478bd9Sstevel@tonic-gate * any return from the auditor, as we can't 10217c478bd9Sstevel@tonic-gate * allow ignore filtering to ld.so.1, otherwise 10227c478bd9Sstevel@tonic-gate * nothing is going to work. 10237c478bd9Sstevel@tonic-gate */ 102456deab07SRod Evans if (nlmp && ((lml->lm_tflags | AFLAGS(ilmp)) & 102502ca3e02Srie LML_TFLG_AUD_OBJFILTER)) 10267c478bd9Sstevel@tonic-gate (void) audit_objfilter(ilmp, filtees, 10277c478bd9Sstevel@tonic-gate nlmp, 0); 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate } else { 10307c478bd9Sstevel@tonic-gate Rej_desc rej = { 0 }; 103156deab07SRod Evans Fdesc fd = { 0 }; 103211a2bb38Srie Aliste lmco; 10337c478bd9Sstevel@tonic-gate 103456deab07SRod Evans /* 103556deab07SRod Evans * Trace the inspection of this file, determine 103656deab07SRod Evans * any auditor substitution, and seed the file 103756deab07SRod Evans * descriptor with the originating name. 103856deab07SRod Evans */ 103956deab07SRod Evans if (load_trace(lml, pdp, clmp, &fd) == NULL) 104056deab07SRod Evans continue; 104156deab07SRod Evans 10427c478bd9Sstevel@tonic-gate /* 1043dde769a2SRod Evans * Establish a link-map control list for this 1044dde769a2SRod Evans * request. 10457c478bd9Sstevel@tonic-gate */ 104667d74cc3SToomas Soome if ((lmco = create_cntl(lml, 0)) == 0) 104767d74cc3SToomas Soome return (0); 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate /* 105056deab07SRod Evans * Locate and load the filtee. 10517c478bd9Sstevel@tonic-gate */ 105256deab07SRod Evans if ((nlmp = load_path(lml, lmco, ilmp, mode, 10532017c965SRod Evans FLG_RT_PUBHDL, &ghp, &fd, &rej, 105456deab07SRod Evans in_nfavl)) == NULL) 10557c478bd9Sstevel@tonic-gate file_notfound(LIST(ilmp), filtee, ilmp, 10562017c965SRod Evans FLG_RT_PUBHDL, &rej); 105756deab07SRod Evans 105856deab07SRod Evans filtee = pdp->pd_pname; 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate /* 10617c478bd9Sstevel@tonic-gate * Establish the filter handle to prevent any 10627c478bd9Sstevel@tonic-gate * recursion. 10637c478bd9Sstevel@tonic-gate */ 10647c478bd9Sstevel@tonic-gate if (nlmp && ghp) { 10657c478bd9Sstevel@tonic-gate ghp->gh_flags |= GPH_FILTEE; 106656deab07SRod Evans pdp->pd_info = (void *)ghp; 10679aa23310Srie 10689aa23310Srie FLAGS1(nlmp) |= FL1_RT_USED; 10697c478bd9Sstevel@tonic-gate } 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate /* 10727c478bd9Sstevel@tonic-gate * Audit the filter/filtee established. A 10737c478bd9Sstevel@tonic-gate * return of 0 indicates the auditor wishes to 10747c478bd9Sstevel@tonic-gate * ignore this filtee. 10757c478bd9Sstevel@tonic-gate */ 10767c478bd9Sstevel@tonic-gate if (nlmp && ((lml->lm_tflags | FLAGS1(ilmp)) & 10777c478bd9Sstevel@tonic-gate LML_TFLG_AUD_OBJFILTER)) { 10787c478bd9Sstevel@tonic-gate if (audit_objfilter(ilmp, filtees, 10797c478bd9Sstevel@tonic-gate nlmp, 0) == 0) { 10807c478bd9Sstevel@tonic-gate audit = 1; 1081481bba9eSRod Evans nlmp = NULL; 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate } 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate /* 10867c478bd9Sstevel@tonic-gate * Finish processing the objects associated with 10877c478bd9Sstevel@tonic-gate * this request. Create an association between 10887c478bd9Sstevel@tonic-gate * this object and the originating filter to 10897c478bd9Sstevel@tonic-gate * provide sufficient information to tear down 10907c478bd9Sstevel@tonic-gate * this filtee if necessary. 10917c478bd9Sstevel@tonic-gate */ 109256deab07SRod Evans if (nlmp && ghp && (((nlmp = analyze_lmc(lml, 10932020b2b6SRod Evans lmco, nlmp, clmp, in_nfavl)) == NULL) || 109456deab07SRod Evans (relocate_lmc(lml, lmco, ilmp, nlmp, 109556deab07SRod Evans in_nfavl) == 0))) 1096481bba9eSRod Evans nlmp = NULL; 10977c478bd9Sstevel@tonic-gate 10987c478bd9Sstevel@tonic-gate /* 10997c478bd9Sstevel@tonic-gate * If the filtee has been successfully 110002ca3e02Srie * processed, then create an association 110102ca3e02Srie * between the filter and filtee. This 110202ca3e02Srie * association provides sufficient information 110302ca3e02Srie * to tear down the filter and filtee if 110402ca3e02Srie * necessary. 11057c478bd9Sstevel@tonic-gate */ 11068af2c5b9Srie DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD)); 11072017c965SRod Evans if (nlmp && ghp && (hdl_add(ghp, ilmp, 11082017c965SRod Evans GPD_FILTER, NULL) == NULL)) 1109481bba9eSRod Evans nlmp = NULL; 111011a2bb38Srie 111156deab07SRod Evans /* 111256deab07SRod Evans * Generate a diagnostic if the filtee couldn't 111356deab07SRod Evans * be loaded. 111456deab07SRod Evans */ 1115481bba9eSRod Evans if (nlmp == NULL) 111656deab07SRod Evans DBG_CALL(Dbg_file_filtee(lml, 0, filtee, 111756deab07SRod Evans audit)); 111856deab07SRod Evans 111911a2bb38Srie /* 112002ca3e02Srie * If this filtee loading has failed, and we've 112102ca3e02Srie * created a new link-map control list to which 112202ca3e02Srie * this request has added objects, then remove 112302ca3e02Srie * all the objects that have been associated to 112402ca3e02Srie * this request. 112511a2bb38Srie */ 1126481bba9eSRod Evans if ((nlmp == NULL) && (lmco != ALIST_OFF_DATA)) 1127481bba9eSRod Evans remove_lmc(lml, clmp, lmco, name); 112802ca3e02Srie 112902ca3e02Srie /* 1130dde769a2SRod Evans * Remove any temporary link-map control list. 113102ca3e02Srie */ 1132481bba9eSRod Evans if (lmco != ALIST_OFF_DATA) 113311a2bb38Srie remove_cntl(lml, lmco); 11347c478bd9Sstevel@tonic-gate } 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate /* 113756deab07SRod Evans * If the filtee couldn't be loaded, null out the 113856deab07SRod Evans * path name descriptor entry, and continue the search. 113956deab07SRod Evans * Otherwise, the group handle is retained for future 114056deab07SRod Evans * symbol searches. 11417c478bd9Sstevel@tonic-gate */ 1142481bba9eSRod Evans if (nlmp == NULL) { 114356deab07SRod Evans pdp->pd_info = NULL; 114456deab07SRod Evans pdp->pd_plen = 0; 11457c478bd9Sstevel@tonic-gate continue; 11467c478bd9Sstevel@tonic-gate } 11477c478bd9Sstevel@tonic-gate } 11487c478bd9Sstevel@tonic-gate 114956deab07SRod Evans ghp = (Grp_hdl *)pdp->pd_info; 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate /* 115208278a5eSRod Evans * If name is NULL, we're here to trigger filtee loading. 115308278a5eSRod Evans * Skip the symbol lookup so that we'll continue looking for 115408278a5eSRod Evans * additional filtees. 11557c478bd9Sstevel@tonic-gate */ 11567c478bd9Sstevel@tonic-gate if (name) { 11577c478bd9Sstevel@tonic-gate Grp_desc *gdp; 115808278a5eSRod Evans int ret = 0; 1159cce0e03bSab Aliste idx; 11607c478bd9Sstevel@tonic-gate Slookup sl = *slp; 11617c478bd9Sstevel@tonic-gate 116208278a5eSRod Evans sl.sl_flags |= (LKUP_FIRST | LKUP_DLSYM); 11637c478bd9Sstevel@tonic-gate any++; 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate /* 11667c478bd9Sstevel@tonic-gate * Look for the symbol in the handles dependencies. 11677c478bd9Sstevel@tonic-gate */ 1168cce0e03bSab for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) { 1169efb9e8b8Srie if ((gdp->gd_flags & GPD_DLSYM) == 0) 11707c478bd9Sstevel@tonic-gate continue; 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate /* 11737c478bd9Sstevel@tonic-gate * If our parent is a dependency don't look at 11747c478bd9Sstevel@tonic-gate * it (otherwise we are in a recursive loop). 11757c478bd9Sstevel@tonic-gate * This situation can occur with auxiliary 11767c478bd9Sstevel@tonic-gate * filters if the filtee has a dependency on the 11777c478bd9Sstevel@tonic-gate * filter. This dependency isn't necessary as 11787c478bd9Sstevel@tonic-gate * auxiliary filters are opened RTLD_PARENT, but 11797c478bd9Sstevel@tonic-gate * users may still unknowingly add an explicit 11807c478bd9Sstevel@tonic-gate * dependency to the parent. 11817c478bd9Sstevel@tonic-gate */ 11827c478bd9Sstevel@tonic-gate if ((sl.sl_imap = gdp->gd_depend) == ilmp) 11837c478bd9Sstevel@tonic-gate continue; 11847c478bd9Sstevel@tonic-gate 118508278a5eSRod Evans if (((ret = SYMINTP(sl.sl_imap)(&sl, srp, binfo, 118608278a5eSRod Evans in_nfavl)) != 0) || 11877c478bd9Sstevel@tonic-gate (ghp->gh_flags & GPH_FIRST)) 11887c478bd9Sstevel@tonic-gate break; 11897c478bd9Sstevel@tonic-gate } 11907c478bd9Sstevel@tonic-gate 11917c478bd9Sstevel@tonic-gate /* 119202ca3e02Srie * If a symbol has been found, indicate the binding 119302ca3e02Srie * and return the symbol. 11947c478bd9Sstevel@tonic-gate */ 119508278a5eSRod Evans if (ret) { 11967c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_FILTEE; 119708278a5eSRod Evans return (1); 11987c478bd9Sstevel@tonic-gate } 11997c478bd9Sstevel@tonic-gate } 12007c478bd9Sstevel@tonic-gate 12017c478bd9Sstevel@tonic-gate /* 12027c478bd9Sstevel@tonic-gate * If this object is tagged to terminate filtee processing we're 12037c478bd9Sstevel@tonic-gate * done. 12047c478bd9Sstevel@tonic-gate */ 12055aefb655Srie if (FLAGS1(ghp->gh_ownlmp) & FL1_RT_ENDFILTE) 12067c478bd9Sstevel@tonic-gate break; 12077c478bd9Sstevel@tonic-gate } 12087c478bd9Sstevel@tonic-gate 12097c478bd9Sstevel@tonic-gate /* 12107c478bd9Sstevel@tonic-gate * If we're just here to trigger filtee loading then we're done. 12117c478bd9Sstevel@tonic-gate */ 1212481bba9eSRod Evans if (name == NULL) 121308278a5eSRod Evans return (0); 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate /* 121656deab07SRod Evans * If no filtees have been found for a filter, clean up any path name 121756deab07SRod Evans * descriptors and disable their search completely. For auxiliary 12187c478bd9Sstevel@tonic-gate * filters we can reselect the symbol search function so that we never 12197c478bd9Sstevel@tonic-gate * enter this routine again for this object. For standard filters we 12207c478bd9Sstevel@tonic-gate * use the null symbol routine. 12217c478bd9Sstevel@tonic-gate */ 12227c478bd9Sstevel@tonic-gate if (any == 0) { 12232020b2b6SRod Evans remove_alist((Alist **)&(dip->di_info), 1); 12247c478bd9Sstevel@tonic-gate elf_disable_filtee(ilmp, dip); 12257c478bd9Sstevel@tonic-gate } 12267c478bd9Sstevel@tonic-gate 122708278a5eSRod Evans return (0); 12287c478bd9Sstevel@tonic-gate } 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate /* 12317c478bd9Sstevel@tonic-gate * Focal point for disabling error messages for auxiliary filters. As an 12327c478bd9Sstevel@tonic-gate * auxiliary filter allows for filtee use, but provides a fallback should a 12337c478bd9Sstevel@tonic-gate * filtee not exist (or fail to load), any errors generated as a consequence of 12347c478bd9Sstevel@tonic-gate * trying to load the filtees are typically suppressed. Setting RT_FL_SILENCERR 123508278a5eSRod Evans * suppresses errors generated by eprintf(), but ensures a debug diagnostic is 123608278a5eSRod Evans * produced. ldd(1) employs printf(), and here the selection of whether to 12377c478bd9Sstevel@tonic-gate * print a diagnostic in regards to auxiliary filters is a little more complex. 12387c478bd9Sstevel@tonic-gate * 12392017c965SRod Evans * - The determination of whether to produce an ldd message, or a fatal 12407c478bd9Sstevel@tonic-gate * error message is driven by LML_FLG_TRC_ENABLE. 12412017c965SRod Evans * - More detailed ldd messages may also be driven off of LML_FLG_TRC_WARN, 12427c478bd9Sstevel@tonic-gate * (ldd -d/-r), LML_FLG_TRC_VERBOSE (ldd -v), LML_FLG_TRC_SEARCH (ldd -s), 12437c478bd9Sstevel@tonic-gate * and LML_FLG_TRC_UNREF/LML_FLG_TRC_UNUSED (ldd -U/-u). 12442017c965SRod Evans * - If the calling object is lddstub, then several classes of message are 12457c478bd9Sstevel@tonic-gate * suppressed. The user isn't trying to diagnose lddstub, this is simply 12467c478bd9Sstevel@tonic-gate * a stub executable employed to preload a user specified library against. 12472017c965SRod Evans * - If RT_FL_SILENCERR is in effect then any generic ldd() messages should 12487c478bd9Sstevel@tonic-gate * be suppressed. All detailed ldd messages should still be produced. 12497c478bd9Sstevel@tonic-gate */ 125008278a5eSRod Evans int 125108278a5eSRod Evans elf_lookup_filtee(Slookup *slp, Sresult *srp, uint_t *binfo, uint_t ndx, 12529aa23310Srie int *in_nfavl) 12537c478bd9Sstevel@tonic-gate { 12547c478bd9Sstevel@tonic-gate Dyninfo *dip = &DYNINFO(slp->sl_imap)[ndx]; 125508278a5eSRod Evans int ret, silent = 0; 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate /* 12587c478bd9Sstevel@tonic-gate * Make sure this entry is still acting as a filter. We may have tried 12597c478bd9Sstevel@tonic-gate * to process this previously, and disabled it if the filtee couldn't 12607c478bd9Sstevel@tonic-gate * be processed. However, other entries may provide different filtees 12617c478bd9Sstevel@tonic-gate * that are yet to be completed. 12627c478bd9Sstevel@tonic-gate */ 12637c478bd9Sstevel@tonic-gate if (dip->di_flags == 0) 126408278a5eSRod Evans return (0); 12657c478bd9Sstevel@tonic-gate 12667c478bd9Sstevel@tonic-gate /* 12677c478bd9Sstevel@tonic-gate * Indicate whether an error message is required should this filtee not 12687c478bd9Sstevel@tonic-gate * be found, based on the type of filter. 12697c478bd9Sstevel@tonic-gate */ 12707c478bd9Sstevel@tonic-gate if ((dip->di_flags & FLG_DI_AUXFLTR) && 12717c478bd9Sstevel@tonic-gate ((rtld_flags & (RT_FL_WARNFLTR | RT_FL_SILENCERR)) == 0)) { 12727c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_SILENCERR; 12737c478bd9Sstevel@tonic-gate silent = 1; 12747c478bd9Sstevel@tonic-gate } 12757c478bd9Sstevel@tonic-gate 127608278a5eSRod Evans ret = _elf_lookup_filtee(slp, srp, binfo, ndx, in_nfavl); 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate if (silent) 12797c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_SILENCERR; 12807c478bd9Sstevel@tonic-gate 128108278a5eSRod Evans return (ret); 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate /* 12857c478bd9Sstevel@tonic-gate * Compute the elf hash value (as defined in the ELF access library). 12867c478bd9Sstevel@tonic-gate * The form of the hash table is: 12877c478bd9Sstevel@tonic-gate * 12887c478bd9Sstevel@tonic-gate * |--------------| 12897c478bd9Sstevel@tonic-gate * | # of buckets | 12907c478bd9Sstevel@tonic-gate * |--------------| 12917c478bd9Sstevel@tonic-gate * | # of chains | 12927c478bd9Sstevel@tonic-gate * |--------------| 12937c478bd9Sstevel@tonic-gate * | bucket[] | 12947c478bd9Sstevel@tonic-gate * |--------------| 12957c478bd9Sstevel@tonic-gate * | chain[] | 12967c478bd9Sstevel@tonic-gate * |--------------| 12977c478bd9Sstevel@tonic-gate */ 12987c478bd9Sstevel@tonic-gate ulong_t 12997c478bd9Sstevel@tonic-gate elf_hash(const char *name) 13007c478bd9Sstevel@tonic-gate { 13017c478bd9Sstevel@tonic-gate uint_t hval = 0; 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate while (*name) { 13047c478bd9Sstevel@tonic-gate uint_t g; 13057c478bd9Sstevel@tonic-gate hval = (hval << 4) + *name++; 13067c478bd9Sstevel@tonic-gate if ((g = (hval & 0xf0000000)) != 0) 13077c478bd9Sstevel@tonic-gate hval ^= g >> 24; 13087c478bd9Sstevel@tonic-gate hval &= ~g; 13097c478bd9Sstevel@tonic-gate } 13107c478bd9Sstevel@tonic-gate return ((ulong_t)hval); 13117c478bd9Sstevel@tonic-gate } 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate /* 131408278a5eSRod Evans * Look up a symbol. The callers lookup information is passed in the Slookup 131508278a5eSRod Evans * structure, and any resultant binding information is returned in the Sresult 131608278a5eSRod Evans * structure. 13177c478bd9Sstevel@tonic-gate */ 131808278a5eSRod Evans int 131908278a5eSRod Evans elf_find_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl) 13207c478bd9Sstevel@tonic-gate { 13217c478bd9Sstevel@tonic-gate const char *name = slp->sl_name; 13227c478bd9Sstevel@tonic-gate Rt_map *ilmp = slp->sl_imap; 13237c478bd9Sstevel@tonic-gate ulong_t hash = slp->sl_hash; 132408278a5eSRod Evans uint_t ndx, hashoff, buckets, *chainptr; 13257c478bd9Sstevel@tonic-gate Sym *sym, *symtabptr; 13267c478bd9Sstevel@tonic-gate char *strtabptr, *strtabname; 13277c478bd9Sstevel@tonic-gate uint_t flags1; 13287c478bd9Sstevel@tonic-gate Syminfo *sip; 13297c478bd9Sstevel@tonic-gate 1330660acd81Srie /* 1331660acd81Srie * If we're only here to establish a symbols index, skip the diagnostic 1332660acd81Srie * used to trace a symbol search. 1333660acd81Srie */ 13345aefb655Srie if ((slp->sl_flags & LKUP_SYMNDX) == 0) 13355aefb655Srie DBG_CALL(Dbg_syms_lookup(ilmp, name, MSG_ORIG(MSG_STR_ELF))); 13367c478bd9Sstevel@tonic-gate 1337481bba9eSRod Evans if (HASH(ilmp) == NULL) 133808278a5eSRod Evans return (0); 13397c478bd9Sstevel@tonic-gate 13407c478bd9Sstevel@tonic-gate buckets = HASH(ilmp)[0]; 13417c478bd9Sstevel@tonic-gate /* LINTED */ 134208278a5eSRod Evans hashoff = ((uint_t)hash % buckets) + 2; 13437c478bd9Sstevel@tonic-gate 13447c478bd9Sstevel@tonic-gate /* 134508278a5eSRod Evans * Get the first symbol from the hash chain and initialize the string 13467c478bd9Sstevel@tonic-gate * and symbol table pointers. 13477c478bd9Sstevel@tonic-gate */ 134808278a5eSRod Evans if ((ndx = HASH(ilmp)[hashoff]) == 0) 134908278a5eSRod Evans return (0); 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate chainptr = HASH(ilmp) + 2 + buckets; 13527c478bd9Sstevel@tonic-gate strtabptr = STRTAB(ilmp); 13537c478bd9Sstevel@tonic-gate symtabptr = SYMTAB(ilmp); 13547c478bd9Sstevel@tonic-gate 13557c478bd9Sstevel@tonic-gate while (ndx) { 13567c478bd9Sstevel@tonic-gate sym = symtabptr + ndx; 13577c478bd9Sstevel@tonic-gate strtabname = strtabptr + sym->st_name; 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate /* 13607c478bd9Sstevel@tonic-gate * Compare the symbol found with the name required. If the 13617c478bd9Sstevel@tonic-gate * names don't match continue with the next hash entry. 13627c478bd9Sstevel@tonic-gate */ 13637c478bd9Sstevel@tonic-gate if ((*strtabname++ != *name) || strcmp(strtabname, &name[1])) { 136408278a5eSRod Evans hashoff = ndx + buckets + 2; 13657c478bd9Sstevel@tonic-gate if ((ndx = chainptr[ndx]) != 0) 13667c478bd9Sstevel@tonic-gate continue; 136708278a5eSRod Evans return (0); 13687c478bd9Sstevel@tonic-gate } 13697c478bd9Sstevel@tonic-gate 137008278a5eSRod Evans /* 137108278a5eSRod Evans * Symbols that are defined as hidden within an object usually 137208278a5eSRod Evans * have any references from within the same object bound at 137308278a5eSRod Evans * link-edit time, thus ld.so.1 is not involved. However, if 137408278a5eSRod Evans * these are capabilities symbols, then references to them must 137508278a5eSRod Evans * be resolved at runtime. A hidden symbol can only be bound 137608278a5eSRod Evans * to by the object that defines the symbol. 137708278a5eSRod Evans */ 137808278a5eSRod Evans if ((sym->st_shndx != SHN_UNDEF) && 137908278a5eSRod Evans (ELF_ST_VISIBILITY(sym->st_other) == STV_HIDDEN) && 138008278a5eSRod Evans (slp->sl_cmap != ilmp)) 138108278a5eSRod Evans return (0); 138208278a5eSRod Evans 13833b41b08bSab /* 1384d840867fSab * The Solaris ld does not put DT_VERSYM in the dynamic 1385d840867fSab * section, but the GNU ld does. The GNU runtime linker 1386d840867fSab * interprets the top bit of the 16-bit Versym value 1387d840867fSab * (0x8000) as the "hidden" bit. If this bit is set, 1388d840867fSab * the linker is supposed to act as if that symbol does 1389d840867fSab * not exist. The hidden bit supports their versioning 1390d840867fSab * scheme, which allows multiple incompatible functions 1391d840867fSab * with the same name to exist at different versions 1392d840867fSab * within an object. The Solaris linker does not support this 1393d840867fSab * mechanism, or the model of interface evolution that 1394d840867fSab * it allows, but we honor the hidden bit in GNU ld 1395d840867fSab * produced objects in order to interoperate with them. 13963b41b08bSab */ 139708278a5eSRod Evans if (VERSYM(ilmp) && (VERSYM(ilmp)[ndx] & 0x8000)) { 1398d840867fSab DBG_CALL(Dbg_syms_ignore_gnuver(ilmp, name, 13993b41b08bSab ndx, VERSYM(ilmp)[ndx])); 140008278a5eSRod Evans return (0); 14013b41b08bSab } 14023b41b08bSab 1403660acd81Srie /* 140408278a5eSRod Evans * If we're only here to establish a symbol's index, we're done. 1405660acd81Srie */ 140608278a5eSRod Evans if (slp->sl_flags & LKUP_SYMNDX) { 140708278a5eSRod Evans srp->sr_dmap = ilmp; 140808278a5eSRod Evans srp->sr_sym = sym; 140908278a5eSRod Evans return (1); 141008278a5eSRod Evans } 1411660acd81Srie 14127c478bd9Sstevel@tonic-gate /* 141308278a5eSRod Evans * If we find a match and the symbol is defined, capture the 14147c478bd9Sstevel@tonic-gate * symbol pointer and the link map in which it was found. 14157c478bd9Sstevel@tonic-gate */ 14167c478bd9Sstevel@tonic-gate if (sym->st_shndx != SHN_UNDEF) { 141708278a5eSRod Evans srp->sr_dmap = ilmp; 141808278a5eSRod Evans srp->sr_sym = sym; 14197c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_FOUND; 142008278a5eSRod Evans 14219a411307Srie if ((FLAGS(ilmp) & FLG_RT_OBJINTPO) || 14229a411307Srie ((FLAGS(ilmp) & FLG_RT_SYMINTPO) && 14239a411307Srie is_sym_interposer(ilmp, sym))) 14247c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_INTERPOSE; 14257c478bd9Sstevel@tonic-gate break; 14267c478bd9Sstevel@tonic-gate 14277c478bd9Sstevel@tonic-gate /* 14287c478bd9Sstevel@tonic-gate * If we find a match and the symbol is undefined, the 14297c478bd9Sstevel@tonic-gate * symbol type is a function, and the value of the symbol 14307c478bd9Sstevel@tonic-gate * is non zero, then this is a special case. This allows 14317c478bd9Sstevel@tonic-gate * the resolution of a function address to the plt[] entry. 14327c478bd9Sstevel@tonic-gate * See SPARC ABI, Dynamic Linking, Function Addresses for 14337c478bd9Sstevel@tonic-gate * more details. 14347c478bd9Sstevel@tonic-gate */ 1435660acd81Srie } else if ((slp->sl_flags & LKUP_SPEC) && 14367c478bd9Sstevel@tonic-gate (FLAGS(ilmp) & FLG_RT_ISMAIN) && (sym->st_value != 0) && 14377c478bd9Sstevel@tonic-gate (ELF_ST_TYPE(sym->st_info) == STT_FUNC)) { 143808278a5eSRod Evans srp->sr_dmap = ilmp; 143908278a5eSRod Evans srp->sr_sym = sym; 14407c478bd9Sstevel@tonic-gate *binfo |= (DBG_BINFO_FOUND | DBG_BINFO_PLTADDR); 144108278a5eSRod Evans 14429a411307Srie if ((FLAGS(ilmp) & FLG_RT_OBJINTPO) || 14439a411307Srie ((FLAGS(ilmp) & FLG_RT_SYMINTPO) && 14449a411307Srie is_sym_interposer(ilmp, sym))) 14457c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_INTERPOSE; 144608278a5eSRod Evans return (1); 14477c478bd9Sstevel@tonic-gate } 14487c478bd9Sstevel@tonic-gate 14497c478bd9Sstevel@tonic-gate /* 14507c478bd9Sstevel@tonic-gate * Undefined symbol. 14517c478bd9Sstevel@tonic-gate */ 145208278a5eSRod Evans return (0); 14537c478bd9Sstevel@tonic-gate } 14547c478bd9Sstevel@tonic-gate 14557c478bd9Sstevel@tonic-gate /* 14567c478bd9Sstevel@tonic-gate * We've found a match. Determine if the defining object contains 14577c478bd9Sstevel@tonic-gate * symbol binding information. 14587c478bd9Sstevel@tonic-gate */ 1459481bba9eSRod Evans if ((sip = SYMINFO(ilmp)) != NULL) 14609039eeafSab sip += ndx; 14617c478bd9Sstevel@tonic-gate 146260758829Srie /* 146360758829Srie * If this definition is a singleton, and we haven't followed a default 146460758829Srie * symbol search knowing that we're looking for a singleton (presumably 146560758829Srie * because the symbol definition has been changed since the referring 146660758829Srie * object was built), then reject this binding so that the caller can 146760758829Srie * fall back to a standard symbol search. 146860758829Srie */ 146960758829Srie if ((ELF_ST_VISIBILITY(sym->st_other) == STV_SINGLETON) && 147060758829Srie (((slp->sl_flags & LKUP_STANDARD) == 0) || 147160758829Srie (((slp->sl_flags & LKUP_SINGLETON) == 0) && 147260758829Srie (LIST(ilmp)->lm_flags & LML_FLG_GROUPSEXIST)))) { 147360758829Srie DBG_CALL(Dbg_bind_reject(slp->sl_cmap, ilmp, name, 147460758829Srie DBG_BNDREJ_SINGLE)); 147560758829Srie *binfo |= BINFO_REJSINGLE; 147660758829Srie *binfo &= ~DBG_BINFO_MSK; 147708278a5eSRod Evans return (0); 147860758829Srie } 147960758829Srie 14807c478bd9Sstevel@tonic-gate /* 14817c478bd9Sstevel@tonic-gate * If this is a direct binding request, but the symbol definition has 14827c478bd9Sstevel@tonic-gate * disabled directly binding to it (presumably because the symbol 14837c478bd9Sstevel@tonic-gate * definition has been changed since the referring object was built), 148437ffaf83SRod Evans * reject this binding so that the caller can fall back to a standard 148560758829Srie * symbol search. 14867c478bd9Sstevel@tonic-gate */ 14877c478bd9Sstevel@tonic-gate if (sip && (slp->sl_flags & LKUP_DIRECT) && 14887c478bd9Sstevel@tonic-gate (sip->si_flags & SYMINFO_FLG_NOEXTDIRECT)) { 148960758829Srie DBG_CALL(Dbg_bind_reject(slp->sl_cmap, ilmp, name, 149037ffaf83SRod Evans DBG_BNDREJ_DIRECT)); 149160758829Srie *binfo |= BINFO_REJDIRECT; 14927c478bd9Sstevel@tonic-gate *binfo &= ~DBG_BINFO_MSK; 149308278a5eSRod Evans return (0); 149437ffaf83SRod Evans } 149537ffaf83SRod Evans 149637ffaf83SRod Evans /* 149737ffaf83SRod Evans * If this is a binding request within an RTLD_GROUP family, and the 149837ffaf83SRod Evans * symbol has disabled directly binding to it, reject this binding so 149937ffaf83SRod Evans * that the caller can fall back to a standard symbol search. 150037ffaf83SRod Evans * 150137ffaf83SRod Evans * Effectively, an RTLD_GROUP family achieves what can now be 150237ffaf83SRod Evans * established with direct bindings. However, various symbols have 150337ffaf83SRod Evans * been tagged as inappropriate for direct binding to (ie. libc:malloc). 150437ffaf83SRod Evans * 150537ffaf83SRod Evans * A symbol marked as no-direct cannot be used within a group without 150637ffaf83SRod Evans * first ensuring that the symbol has not been interposed upon outside 150737ffaf83SRod Evans * of the group. A common example occurs when users implement their own 150837ffaf83SRod Evans * version of malloc() in the executable. Such a malloc() interposes on 150937ffaf83SRod Evans * the libc:malloc, and this interposition must be honored within the 151037ffaf83SRod Evans * group as well. 151137ffaf83SRod Evans * 151237ffaf83SRod Evans * Following any rejection, LKUP_WORLD is established as a means of 151337ffaf83SRod Evans * overriding this test as we return to a standard search. 151437ffaf83SRod Evans */ 151537ffaf83SRod Evans if (sip && (sip->si_flags & SYMINFO_FLG_NOEXTDIRECT) && 151637ffaf83SRod Evans ((MODE(slp->sl_cmap) & (RTLD_GROUP | RTLD_WORLD)) == RTLD_GROUP) && 151737ffaf83SRod Evans ((slp->sl_flags & LKUP_WORLD) == 0)) { 151837ffaf83SRod Evans DBG_CALL(Dbg_bind_reject(slp->sl_cmap, ilmp, name, 151937ffaf83SRod Evans DBG_BNDREJ_GROUP)); 152037ffaf83SRod Evans *binfo |= BINFO_REJGROUP; 152137ffaf83SRod Evans *binfo &= ~DBG_BINFO_MSK; 152208278a5eSRod Evans return (0); 15237c478bd9Sstevel@tonic-gate } 15247c478bd9Sstevel@tonic-gate 152508278a5eSRod Evans /* 152608278a5eSRod Evans * If this symbol is associated with capabilities, then each of the 152708278a5eSRod Evans * capabilities instances needs to be compared against the system 152808278a5eSRod Evans * capabilities. The best instance will be chosen to satisfy this 152908278a5eSRod Evans * binding. 153008278a5eSRod Evans */ 153108278a5eSRod Evans if (CAP(ilmp) && CAPINFO(ilmp) && ELF_C_GROUP(CAPINFO(ilmp)[ndx]) && 153208278a5eSRod Evans (cap_match(srp, ndx, symtabptr, strtabptr) == 0)) 153308278a5eSRod Evans return (0); 153408278a5eSRod Evans 15357c478bd9Sstevel@tonic-gate /* 15367c478bd9Sstevel@tonic-gate * Determine whether this object is acting as a filter. 15377c478bd9Sstevel@tonic-gate */ 15387c478bd9Sstevel@tonic-gate if (((flags1 = FLAGS1(ilmp)) & MSK_RT_FILTER) == 0) 153908278a5eSRod Evans return (1); 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate /* 15427c478bd9Sstevel@tonic-gate * Determine if this object offers per-symbol filtering, and if so, 15437c478bd9Sstevel@tonic-gate * whether this symbol references a filtee. 15447c478bd9Sstevel@tonic-gate */ 15457c478bd9Sstevel@tonic-gate if (sip && (flags1 & (FL1_RT_SYMSFLTR | FL1_RT_SYMAFLTR))) { 15467c478bd9Sstevel@tonic-gate /* 15477c478bd9Sstevel@tonic-gate * If this is a standard filter reference, and no standard 15487c478bd9Sstevel@tonic-gate * filtees remain to be inspected, we're done. If this is an 15497c478bd9Sstevel@tonic-gate * auxiliary filter reference, and no auxiliary filtees remain, 15507c478bd9Sstevel@tonic-gate * we'll fall through in case any object filtering is available. 15517c478bd9Sstevel@tonic-gate */ 15527c478bd9Sstevel@tonic-gate if ((sip->si_flags & SYMINFO_FLG_FILTER) && 15537c478bd9Sstevel@tonic-gate (SYMSFLTRCNT(ilmp) == 0)) 155408278a5eSRod Evans return (0); 15557c478bd9Sstevel@tonic-gate 15567c478bd9Sstevel@tonic-gate if ((sip->si_flags & SYMINFO_FLG_FILTER) || 15577c478bd9Sstevel@tonic-gate ((sip->si_flags & SYMINFO_FLG_AUXILIARY) && 15587c478bd9Sstevel@tonic-gate SYMAFLTRCNT(ilmp))) { 155908278a5eSRod Evans Sresult sr; 156008278a5eSRod Evans 156108278a5eSRod Evans /* 156208278a5eSRod Evans * Initialize a local symbol result descriptor, using 156308278a5eSRod Evans * the original symbol name. 156408278a5eSRod Evans */ 156508278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name); 15667c478bd9Sstevel@tonic-gate 15677c478bd9Sstevel@tonic-gate /* 15687c478bd9Sstevel@tonic-gate * This symbol has an associated filtee. Lookup the 15697c478bd9Sstevel@tonic-gate * symbol in the filtee, and if it is found return it. 15707c478bd9Sstevel@tonic-gate * If the symbol doesn't exist, and this is a standard 15717c478bd9Sstevel@tonic-gate * filter, return an error, otherwise fall through to 15727c478bd9Sstevel@tonic-gate * catch any object filtering that may be available. 15737c478bd9Sstevel@tonic-gate */ 157408278a5eSRod Evans if (elf_lookup_filtee(slp, &sr, binfo, sip->si_boundto, 157508278a5eSRod Evans in_nfavl)) { 157608278a5eSRod Evans *srp = sr; 157708278a5eSRod Evans return (1); 157808278a5eSRod Evans } 15797c478bd9Sstevel@tonic-gate if (sip->si_flags & SYMINFO_FLG_FILTER) 158008278a5eSRod Evans return (0); 15817c478bd9Sstevel@tonic-gate } 15827c478bd9Sstevel@tonic-gate } 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate /* 15857c478bd9Sstevel@tonic-gate * Determine if this object provides global filtering. 15867c478bd9Sstevel@tonic-gate */ 15877c478bd9Sstevel@tonic-gate if (flags1 & (FL1_RT_OBJSFLTR | FL1_RT_OBJAFLTR)) { 15887c478bd9Sstevel@tonic-gate if (OBJFLTRNDX(ilmp) != FLTR_DISABLED) { 158908278a5eSRod Evans Sresult sr; 159008278a5eSRod Evans 159108278a5eSRod Evans /* 159208278a5eSRod Evans * Initialize a local symbol result descriptor, using 159308278a5eSRod Evans * the original symbol name. 159408278a5eSRod Evans */ 159508278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name); 159608278a5eSRod Evans 15977c478bd9Sstevel@tonic-gate /* 15987c478bd9Sstevel@tonic-gate * This object has an associated filtee. Lookup the 15997c478bd9Sstevel@tonic-gate * symbol in the filtee, and if it is found return it. 16007c478bd9Sstevel@tonic-gate * If the symbol doesn't exist, and this is a standard 16017c478bd9Sstevel@tonic-gate * filter, return and error, otherwise return the symbol 16027c478bd9Sstevel@tonic-gate * within the filter itself. 16037c478bd9Sstevel@tonic-gate */ 160408278a5eSRod Evans if (elf_lookup_filtee(slp, &sr, binfo, OBJFLTRNDX(ilmp), 160508278a5eSRod Evans in_nfavl)) { 160608278a5eSRod Evans *srp = sr; 160708278a5eSRod Evans return (1); 160808278a5eSRod Evans } 16097c478bd9Sstevel@tonic-gate } 16107c478bd9Sstevel@tonic-gate 16117c478bd9Sstevel@tonic-gate if (flags1 & FL1_RT_OBJSFLTR) 161208278a5eSRod Evans return (0); 16137c478bd9Sstevel@tonic-gate } 161408278a5eSRod Evans return (1); 16157c478bd9Sstevel@tonic-gate } 16167c478bd9Sstevel@tonic-gate 16177c478bd9Sstevel@tonic-gate /* 16187c478bd9Sstevel@tonic-gate * Create a new Rt_map structure for an ELF object and initialize 16197c478bd9Sstevel@tonic-gate * all values. 16207c478bd9Sstevel@tonic-gate */ 16217c478bd9Sstevel@tonic-gate Rt_map * 162256deab07SRod Evans elf_new_lmp(Lm_list *lml, Aliste lmco, Fdesc *fdp, Addr addr, size_t msize, 16232020b2b6SRod Evans void *odyn, Rt_map *clmp, int *in_nfavl) 16247c478bd9Sstevel@tonic-gate { 162556deab07SRod Evans const char *name = fdp->fd_nname; 16267c478bd9Sstevel@tonic-gate Rt_map *lmp; 16277c478bd9Sstevel@tonic-gate Ehdr *ehdr = (Ehdr *)addr; 162856deab07SRod Evans Phdr *phdr, *tphdr = NULL, *dphdr = NULL, *uphdr = NULL; 162956deab07SRod Evans Dyn *dyn = (Dyn *)odyn; 163056deab07SRod Evans Cap *cap = NULL; 163156deab07SRod Evans int ndx; 163256deab07SRod Evans Addr base, fltr = 0, audit = 0, cfile = 0, crle = 0; 163356deab07SRod Evans Xword rpath = 0; 163456deab07SRod Evans size_t lmsz, rtsz, epsz, dynsz = 0; 163556deab07SRod Evans uint_t dyncnt = 0; 16367c478bd9Sstevel@tonic-gate 163756deab07SRod Evans DBG_CALL(Dbg_file_elf(lml, name, addr, msize, lml->lm_lmidstr, lmco)); 16387c478bd9Sstevel@tonic-gate 16397c478bd9Sstevel@tonic-gate /* 164056deab07SRod Evans * If this is a shared object, the base address of the shared object is 164156deab07SRod Evans * added to all address values defined within the object. Otherwise, if 164256deab07SRod Evans * this is an executable, all object addresses are used as is. 16437c478bd9Sstevel@tonic-gate */ 164456deab07SRod Evans if (ehdr->e_type == ET_EXEC) 164556deab07SRod Evans base = 0; 164656deab07SRod Evans else 164756deab07SRod Evans base = addr; 164856deab07SRod Evans 164956deab07SRod Evans /* 165056deab07SRod Evans * Traverse the program header table, picking off required items. This 165156deab07SRod Evans * traversal also provides for the sizing of the PT_DYNAMIC section. 165256deab07SRod Evans */ 165356deab07SRod Evans phdr = (Phdr *)((uintptr_t)ehdr + ehdr->e_phoff); 165456deab07SRod Evans for (ndx = 0; ndx < (int)ehdr->e_phnum; ndx++, 165556deab07SRod Evans phdr = (Phdr *)((uintptr_t)phdr + ehdr->e_phentsize)) { 165656deab07SRod Evans switch (phdr->p_type) { 165756deab07SRod Evans case PT_DYNAMIC: 165856deab07SRod Evans dphdr = phdr; 165956deab07SRod Evans dyn = (Dyn *)((uintptr_t)phdr->p_vaddr + base); 166056deab07SRod Evans break; 166156deab07SRod Evans case PT_TLS: 166256deab07SRod Evans tphdr = phdr; 166356deab07SRod Evans break; 166456deab07SRod Evans case PT_SUNWCAP: 166556deab07SRod Evans cap = (Cap *)((uintptr_t)phdr->p_vaddr + base); 166656deab07SRod Evans break; 166756deab07SRod Evans case PT_SUNW_UNWIND: 16687e16fca0SAli Bahrami case PT_SUNW_EH_FRAME: 166956deab07SRod Evans uphdr = phdr; 167056deab07SRod Evans break; 167156deab07SRod Evans default: 167256deab07SRod Evans break; 167356deab07SRod Evans } 16747c478bd9Sstevel@tonic-gate } 16757c478bd9Sstevel@tonic-gate 167656deab07SRod Evans /* 167756deab07SRod Evans * Determine the number of PT_DYNAMIC entries for the DYNINFO() 167856deab07SRod Evans * allocation. Sadly, this is a little larger than we really need, 167956deab07SRod Evans * as there are typically padding DT_NULL entries. However, adding 168056deab07SRod Evans * this data to the initial link-map allocation is a win. 168156deab07SRod Evans */ 168256deab07SRod Evans if (dyn) { 168356deab07SRod Evans dyncnt = dphdr->p_filesz / sizeof (Dyn); 168456deab07SRod Evans dynsz = dyncnt * sizeof (Dyninfo); 168556deab07SRod Evans } 168656deab07SRod Evans 168756deab07SRod Evans /* 168856deab07SRod Evans * Allocate space for the link-map, private elf information, and 168956deab07SRod Evans * DYNINFO() data. Once these are allocated and initialized, 169056deab07SRod Evans * remove_so(0, lmp) can be used to tear down the link-map allocation 169156deab07SRod Evans * should any failures occur. 169256deab07SRod Evans */ 169356deab07SRod Evans rtsz = S_DROUND(sizeof (Rt_map)); 169456deab07SRod Evans epsz = S_DROUND(sizeof (Rt_elfp)); 169556deab07SRod Evans lmsz = rtsz + epsz + dynsz; 169656deab07SRod Evans if ((lmp = calloc(lmsz, 1)) == NULL) 169756deab07SRod Evans return (NULL); 169856deab07SRod Evans ELFPRV(lmp) = (void *)((uintptr_t)lmp + rtsz); 169956deab07SRod Evans DYNINFO(lmp) = (Dyninfo *)((uintptr_t)lmp + rtsz + epsz); 170056deab07SRod Evans LMSIZE(lmp) = lmsz; 170156deab07SRod Evans 17027c478bd9Sstevel@tonic-gate /* 17037c478bd9Sstevel@tonic-gate * All fields not filled in were set to 0 by calloc. 17047c478bd9Sstevel@tonic-gate */ 170556deab07SRod Evans NAME(lmp) = (char *)name; 17067c478bd9Sstevel@tonic-gate ADDR(lmp) = addr; 17077c478bd9Sstevel@tonic-gate MSIZE(lmp) = msize; 17087c478bd9Sstevel@tonic-gate SYMINTP(lmp) = elf_find_sym; 17097c478bd9Sstevel@tonic-gate FCT(lmp) = &elf_fct; 17107c478bd9Sstevel@tonic-gate LIST(lmp) = lml; 17117c478bd9Sstevel@tonic-gate OBJFLTRNDX(lmp) = FLTR_DISABLED; 1712dffec89cSrie SORTVAL(lmp) = -1; 171356deab07SRod Evans DYN(lmp) = dyn; 171456deab07SRod Evans DYNINFOCNT(lmp) = dyncnt; 171556deab07SRod Evans PTUNWIND(lmp) = uphdr; 17167c478bd9Sstevel@tonic-gate 171756deab07SRod Evans if (ehdr->e_type == ET_EXEC) 17187c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_FIXED; 17197c478bd9Sstevel@tonic-gate 17207c478bd9Sstevel@tonic-gate /* 17217c478bd9Sstevel@tonic-gate * Fill in rest of the link map entries with information from the file's 17227c478bd9Sstevel@tonic-gate * dynamic structure. 17237c478bd9Sstevel@tonic-gate */ 172456deab07SRod Evans if (dyn) { 1725f441771bSRod Evans Dyninfo *dip; 1726f441771bSRod Evans uint_t dynndx; 172710a4fa49Srie Xword pltpadsz = 0; 172810a4fa49Srie Rti_desc *rti; 1729f441771bSRod Evans Dyn *pdyn; 1730f441771bSRod Evans Word lmtflags = lml->lm_tflags; 1731f441771bSRod Evans int ignore = 0; 1732f441771bSRod Evans 1733f441771bSRod Evans /* 1734f441771bSRod Evans * Note, we use DT_NULL to terminate processing, and the 1735f441771bSRod Evans * dynamic entry count as a fall back. Normally, a DT_NULL 1736f441771bSRod Evans * entry marks the end of the dynamic section. Any non-NULL 1737f441771bSRod Evans * items following the first DT_NULL are silently ignored. 1738f441771bSRod Evans * This situation should only occur through use of elfedit(1) 1739f441771bSRod Evans * or a similar tool. 1740f441771bSRod Evans */ 1741f441771bSRod Evans for (dynndx = 0, pdyn = NULL, dip = DYNINFO(lmp); 1742f441771bSRod Evans dynndx < dyncnt; dynndx++, pdyn = dyn++, dip++) { 1743f441771bSRod Evans 1744f441771bSRod Evans if (ignore) { 1745f441771bSRod Evans dip->di_flags |= FLG_DI_IGNORE; 1746f441771bSRod Evans continue; 1747f441771bSRod Evans } 17487c478bd9Sstevel@tonic-gate 174956deab07SRod Evans switch ((Xword)dyn->d_tag) { 1750f441771bSRod Evans case DT_NULL: 1751f441771bSRod Evans dip->di_flags |= ignore = FLG_DI_IGNORE; 1752f441771bSRod Evans break; 1753f441771bSRod Evans case DT_POSFLAG_1: 1754f441771bSRod Evans dip->di_flags |= FLG_DI_POSFLAG1; 1755f441771bSRod Evans break; 1756f441771bSRod Evans case DT_NEEDED: 1757f441771bSRod Evans case DT_USED: 1758f441771bSRod Evans dip->di_flags |= FLG_DI_NEEDED; 1759f441771bSRod Evans 1760f441771bSRod Evans /* BEGIN CSTYLED */ 1761f441771bSRod Evans if (pdyn && (pdyn->d_tag == DT_POSFLAG_1)) { 1762f441771bSRod Evans /* 1763f441771bSRod Evans * Identify any non-deferred lazy load for 1764f441771bSRod Evans * future processing, unless LD_NOLAZYLOAD 1765f441771bSRod Evans * has been set. 1766f441771bSRod Evans */ 1767f441771bSRod Evans if ((pdyn->d_un.d_val & DF_P1_LAZYLOAD) && 1768f441771bSRod Evans ((lmtflags & LML_TFLG_NOLAZYLD) == 0)) 1769f441771bSRod Evans dip->di_flags |= FLG_DI_LAZY; 1770f441771bSRod Evans 1771f441771bSRod Evans /* 1772f441771bSRod Evans * Identify any group permission 1773f441771bSRod Evans * requirements. 1774f441771bSRod Evans */ 1775f441771bSRod Evans if (pdyn->d_un.d_val & DF_P1_GROUPPERM) 1776f441771bSRod Evans dip->di_flags |= FLG_DI_GROUP; 1777f441771bSRod Evans 1778f441771bSRod Evans /* 1779f441771bSRod Evans * Identify any deferred dependencies. 1780f441771bSRod Evans */ 1781f441771bSRod Evans if (pdyn->d_un.d_val & DF_P1_DEFERRED) 1782f441771bSRod Evans dip->di_flags |= FLG_DI_DEFERRED; 1783f441771bSRod Evans } 1784f441771bSRod Evans /* END CSTYLED */ 1785f441771bSRod Evans break; 17867c478bd9Sstevel@tonic-gate case DT_SYMTAB: 178756deab07SRod Evans SYMTAB(lmp) = (void *)(dyn->d_un.d_ptr + base); 17887c478bd9Sstevel@tonic-gate break; 17899039eeafSab case DT_SUNW_SYMTAB: 17909039eeafSab SUNWSYMTAB(lmp) = 179156deab07SRod Evans (void *)(dyn->d_un.d_ptr + base); 17929039eeafSab break; 17939039eeafSab case DT_SUNW_SYMSZ: 179456deab07SRod Evans SUNWSYMSZ(lmp) = dyn->d_un.d_val; 17959039eeafSab break; 17967c478bd9Sstevel@tonic-gate case DT_STRTAB: 179756deab07SRod Evans STRTAB(lmp) = (void *)(dyn->d_un.d_ptr + base); 17987c478bd9Sstevel@tonic-gate break; 17997c478bd9Sstevel@tonic-gate case DT_SYMENT: 180056deab07SRod Evans SYMENT(lmp) = dyn->d_un.d_val; 18017c478bd9Sstevel@tonic-gate break; 18027c478bd9Sstevel@tonic-gate case DT_FEATURE_1: 180356deab07SRod Evans if (dyn->d_un.d_val & DTF_1_CONFEXP) 18047c478bd9Sstevel@tonic-gate crle = 1; 18057c478bd9Sstevel@tonic-gate break; 18067c478bd9Sstevel@tonic-gate case DT_MOVESZ: 180756deab07SRod Evans MOVESZ(lmp) = dyn->d_un.d_val; 18087c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_MOVE; 18097c478bd9Sstevel@tonic-gate break; 18107c478bd9Sstevel@tonic-gate case DT_MOVEENT: 181156deab07SRod Evans MOVEENT(lmp) = dyn->d_un.d_val; 18127c478bd9Sstevel@tonic-gate break; 18137c478bd9Sstevel@tonic-gate case DT_MOVETAB: 181456deab07SRod Evans MOVETAB(lmp) = (void *)(dyn->d_un.d_ptr + base); 18157c478bd9Sstevel@tonic-gate break; 18167c478bd9Sstevel@tonic-gate case DT_REL: 18177c478bd9Sstevel@tonic-gate case DT_RELA: 18187c478bd9Sstevel@tonic-gate /* 181975e7992aSrie * At this time, ld.so. can only handle one 182075e7992aSrie * type of relocation per object. 18217c478bd9Sstevel@tonic-gate */ 182256deab07SRod Evans REL(lmp) = (void *)(dyn->d_un.d_ptr + base); 18237c478bd9Sstevel@tonic-gate break; 18247c478bd9Sstevel@tonic-gate case DT_RELSZ: 18257c478bd9Sstevel@tonic-gate case DT_RELASZ: 182656deab07SRod Evans RELSZ(lmp) = dyn->d_un.d_val; 18277c478bd9Sstevel@tonic-gate break; 18287c478bd9Sstevel@tonic-gate case DT_RELENT: 18297c478bd9Sstevel@tonic-gate case DT_RELAENT: 183056deab07SRod Evans RELENT(lmp) = dyn->d_un.d_val; 18317c478bd9Sstevel@tonic-gate break; 18327c478bd9Sstevel@tonic-gate case DT_RELCOUNT: 18337c478bd9Sstevel@tonic-gate case DT_RELACOUNT: 183456deab07SRod Evans RELACOUNT(lmp) = (uint_t)dyn->d_un.d_val; 18357c478bd9Sstevel@tonic-gate break; 18367c478bd9Sstevel@tonic-gate case DT_HASH: 183756deab07SRod Evans HASH(lmp) = (uint_t *)(dyn->d_un.d_ptr + base); 18387c478bd9Sstevel@tonic-gate break; 18397c478bd9Sstevel@tonic-gate case DT_PLTGOT: 184056deab07SRod Evans PLTGOT(lmp) = 184156deab07SRod Evans (uint_t *)(dyn->d_un.d_ptr + base); 18427c478bd9Sstevel@tonic-gate break; 18437c478bd9Sstevel@tonic-gate case DT_PLTRELSZ: 184456deab07SRod Evans PLTRELSZ(lmp) = dyn->d_un.d_val; 18457c478bd9Sstevel@tonic-gate break; 18467c478bd9Sstevel@tonic-gate case DT_JMPREL: 184756deab07SRod Evans JMPREL(lmp) = (void *)(dyn->d_un.d_ptr + base); 18487c478bd9Sstevel@tonic-gate break; 18497c478bd9Sstevel@tonic-gate case DT_INIT: 185067d74cc3SToomas Soome if (dyn->d_un.d_ptr != 0) 18515b59e4caSab INIT(lmp) = 185256deab07SRod Evans (void (*)())(dyn->d_un.d_ptr + 185356deab07SRod Evans base); 18547c478bd9Sstevel@tonic-gate break; 18557c478bd9Sstevel@tonic-gate case DT_FINI: 185667d74cc3SToomas Soome if (dyn->d_un.d_ptr != 0) 18575b59e4caSab FINI(lmp) = 185856deab07SRod Evans (void (*)())(dyn->d_un.d_ptr + 185956deab07SRod Evans base); 18607c478bd9Sstevel@tonic-gate break; 18617c478bd9Sstevel@tonic-gate case DT_INIT_ARRAY: 186256deab07SRod Evans INITARRAY(lmp) = (Addr *)(dyn->d_un.d_ptr + 18637c478bd9Sstevel@tonic-gate base); 18647c478bd9Sstevel@tonic-gate break; 18657c478bd9Sstevel@tonic-gate case DT_INIT_ARRAYSZ: 186656deab07SRod Evans INITARRAYSZ(lmp) = (uint_t)dyn->d_un.d_val; 18677c478bd9Sstevel@tonic-gate break; 18687c478bd9Sstevel@tonic-gate case DT_FINI_ARRAY: 186956deab07SRod Evans FINIARRAY(lmp) = (Addr *)(dyn->d_un.d_ptr + 18707c478bd9Sstevel@tonic-gate base); 18717c478bd9Sstevel@tonic-gate break; 18727c478bd9Sstevel@tonic-gate case DT_FINI_ARRAYSZ: 187356deab07SRod Evans FINIARRAYSZ(lmp) = (uint_t)dyn->d_un.d_val; 18747c478bd9Sstevel@tonic-gate break; 18757c478bd9Sstevel@tonic-gate case DT_PREINIT_ARRAY: 187656deab07SRod Evans PREINITARRAY(lmp) = (Addr *)(dyn->d_un.d_ptr + 18777c478bd9Sstevel@tonic-gate base); 18787c478bd9Sstevel@tonic-gate break; 18797c478bd9Sstevel@tonic-gate case DT_PREINIT_ARRAYSZ: 188056deab07SRod Evans PREINITARRAYSZ(lmp) = (uint_t)dyn->d_un.d_val; 18817c478bd9Sstevel@tonic-gate break; 18827c478bd9Sstevel@tonic-gate case DT_RPATH: 18837c478bd9Sstevel@tonic-gate case DT_RUNPATH: 188456deab07SRod Evans rpath = dyn->d_un.d_val; 18857c478bd9Sstevel@tonic-gate break; 18867c478bd9Sstevel@tonic-gate case DT_FILTER: 1887f441771bSRod Evans dip->di_flags |= FLG_DI_STDFLTR; 188856deab07SRod Evans fltr = dyn->d_un.d_val; 188975e7992aSrie OBJFLTRNDX(lmp) = dynndx; 18907c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_OBJSFLTR; 18917c478bd9Sstevel@tonic-gate break; 18927c478bd9Sstevel@tonic-gate case DT_AUXILIARY: 1893f441771bSRod Evans dip->di_flags |= FLG_DI_AUXFLTR; 18947c478bd9Sstevel@tonic-gate if (!(rtld_flags & RT_FL_NOAUXFLTR)) { 189556deab07SRod Evans fltr = dyn->d_un.d_val; 189675e7992aSrie OBJFLTRNDX(lmp) = dynndx; 18977c478bd9Sstevel@tonic-gate } 18987c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_OBJAFLTR; 18997c478bd9Sstevel@tonic-gate break; 19007c478bd9Sstevel@tonic-gate case DT_SUNW_FILTER: 1901f441771bSRod Evans dip->di_flags |= 1902f441771bSRod Evans (FLG_DI_STDFLTR | FLG_DI_SYMFLTR); 19037c478bd9Sstevel@tonic-gate SYMSFLTRCNT(lmp)++; 19047c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_SYMSFLTR; 19057c478bd9Sstevel@tonic-gate break; 19067c478bd9Sstevel@tonic-gate case DT_SUNW_AUXILIARY: 1907f441771bSRod Evans dip->di_flags |= 1908f441771bSRod Evans (FLG_DI_AUXFLTR | FLG_DI_SYMFLTR); 19097c478bd9Sstevel@tonic-gate if (!(rtld_flags & RT_FL_NOAUXFLTR)) { 19107c478bd9Sstevel@tonic-gate SYMAFLTRCNT(lmp)++; 19117c478bd9Sstevel@tonic-gate } 19127c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_SYMAFLTR; 19137c478bd9Sstevel@tonic-gate break; 19147c478bd9Sstevel@tonic-gate case DT_DEPAUDIT: 1915b533f56bSRobert Mustacchi if (!(rtld_flags & RT_FL_NOAUDIT)) { 191656deab07SRod Evans audit = dyn->d_un.d_val; 1917b533f56bSRobert Mustacchi FLAGS1(lmp) |= FL1_RT_DEPAUD; 1918b533f56bSRobert Mustacchi } 19197c478bd9Sstevel@tonic-gate break; 19207c478bd9Sstevel@tonic-gate case DT_CONFIG: 192156deab07SRod Evans cfile = dyn->d_un.d_val; 19227c478bd9Sstevel@tonic-gate break; 19237c478bd9Sstevel@tonic-gate case DT_DEBUG: 19247c478bd9Sstevel@tonic-gate /* 19257c478bd9Sstevel@tonic-gate * DT_DEBUG entries are only created in 19267c478bd9Sstevel@tonic-gate * dynamic objects that require an interpretor 19277c478bd9Sstevel@tonic-gate * (ie. all dynamic executables and some shared 19287c478bd9Sstevel@tonic-gate * objects), and provide for a hand-shake with 1929dde769a2SRod Evans * old debuggers. This entry is initialized to 1930dde769a2SRod Evans * zero by the link-editor. If a debugger is 1931dde769a2SRod Evans * monitoring us, and has updated this entry, 1932dde769a2SRod Evans * set the debugger monitor flag, and finish 1933dde769a2SRod Evans * initializing the debugging structure. See 1934dde769a2SRod Evans * setup(). Also, switch off any configuration 1935dde769a2SRod Evans * object use as most debuggers can't handle 1936dde769a2SRod Evans * fixed dynamic executables as dependencies. 19377c478bd9Sstevel@tonic-gate */ 193856deab07SRod Evans if (dyn->d_un.d_ptr) 19397c478bd9Sstevel@tonic-gate rtld_flags |= 19407c478bd9Sstevel@tonic-gate (RT_FL_DEBUGGER | RT_FL_NOOBJALT); 194156deab07SRod Evans dyn->d_un.d_ptr = (Addr)&r_debug; 19427c478bd9Sstevel@tonic-gate break; 19437c478bd9Sstevel@tonic-gate case DT_VERNEED: 194456deab07SRod Evans VERNEED(lmp) = (Verneed *)(dyn->d_un.d_ptr + 19457c478bd9Sstevel@tonic-gate base); 19467c478bd9Sstevel@tonic-gate break; 19477c478bd9Sstevel@tonic-gate case DT_VERNEEDNUM: 19487c478bd9Sstevel@tonic-gate /* LINTED */ 194956deab07SRod Evans VERNEEDNUM(lmp) = (int)dyn->d_un.d_val; 19507c478bd9Sstevel@tonic-gate break; 19517c478bd9Sstevel@tonic-gate case DT_VERDEF: 195256deab07SRod Evans VERDEF(lmp) = (Verdef *)(dyn->d_un.d_ptr + 195356deab07SRod Evans base); 19547c478bd9Sstevel@tonic-gate break; 19557c478bd9Sstevel@tonic-gate case DT_VERDEFNUM: 19567c478bd9Sstevel@tonic-gate /* LINTED */ 195756deab07SRod Evans VERDEFNUM(lmp) = (int)dyn->d_un.d_val; 19587c478bd9Sstevel@tonic-gate break; 19593b41b08bSab case DT_VERSYM: 1960d840867fSab /* 1961d840867fSab * The Solaris ld does not produce DT_VERSYM, 1962d840867fSab * but the GNU ld does, in order to support 1963d840867fSab * their style of versioning, which differs 1964d840867fSab * from ours in some ways, while using the 1965d840867fSab * same data structures. The presence of 1966d840867fSab * DT_VERSYM therefore means that GNU 1967d840867fSab * versioning rules apply to the given file. 1968d840867fSab * If DT_VERSYM is not present, then Solaris 1969d840867fSab * versioning rules apply. 1970d840867fSab */ 197156deab07SRod Evans VERSYM(lmp) = (Versym *)(dyn->d_un.d_ptr + 197256deab07SRod Evans base); 19733b41b08bSab break; 19747c478bd9Sstevel@tonic-gate case DT_BIND_NOW: 197556deab07SRod Evans if ((dyn->d_un.d_val & DF_BIND_NOW) && 197656deab07SRod Evans ((rtld_flags2 & RT_FL2_BINDLAZY) == 0)) { 19777c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_NOW; 19787c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_LAZY; 19797c478bd9Sstevel@tonic-gate } 19807c478bd9Sstevel@tonic-gate break; 19817c478bd9Sstevel@tonic-gate case DT_FLAGS: 198256deab07SRod Evans FLAGS1(lmp) |= FL1_RT_DTFLAGS; 198356deab07SRod Evans if (dyn->d_un.d_val & DF_SYMBOLIC) 19847c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_SYMBOLIC; 198556deab07SRod Evans if ((dyn->d_un.d_val & DF_BIND_NOW) && 1986dffec89cSrie ((rtld_flags2 & RT_FL2_BINDLAZY) == 0)) { 19877c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_NOW; 19887c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_LAZY; 19897c478bd9Sstevel@tonic-gate } 1990d326b23bSrie /* 1991d326b23bSrie * Capture any static TLS use, and enforce that 1992d326b23bSrie * this object be non-deletable. 1993d326b23bSrie */ 199456deab07SRod Evans if (dyn->d_un.d_val & DF_STATIC_TLS) { 1995d326b23bSrie FLAGS1(lmp) |= FL1_RT_TLSSTAT; 1996d326b23bSrie MODE(lmp) |= RTLD_NODELETE; 1997d326b23bSrie } 19987c478bd9Sstevel@tonic-gate break; 19997c478bd9Sstevel@tonic-gate case DT_FLAGS_1: 200056deab07SRod Evans if (dyn->d_un.d_val & DF_1_DISPRELPND) 20017c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_DISPREL; 200256deab07SRod Evans if (dyn->d_un.d_val & DF_1_GROUP) 20037c478bd9Sstevel@tonic-gate FLAGS(lmp) |= 20042017c965SRod Evans (FLG_RT_SETGROUP | FLG_RT_PUBHDL); 200556deab07SRod Evans if ((dyn->d_un.d_val & DF_1_NOW) && 2006dffec89cSrie ((rtld_flags2 & RT_FL2_BINDLAZY) == 0)) { 20077c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_NOW; 20087c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_LAZY; 20097c478bd9Sstevel@tonic-gate } 201056deab07SRod Evans if (dyn->d_un.d_val & DF_1_NODELETE) 20117c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_NODELETE; 201256deab07SRod Evans if (dyn->d_un.d_val & DF_1_INITFIRST) 20137c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_INITFRST; 201456deab07SRod Evans if (dyn->d_un.d_val & DF_1_NOOPEN) 20157c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_NOOPEN; 201656deab07SRod Evans if (dyn->d_un.d_val & DF_1_LOADFLTR) 20177c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_LOADFLTR; 201856deab07SRod Evans if (dyn->d_un.d_val & DF_1_NODUMP) 20197c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_NODUMP; 202056deab07SRod Evans if (dyn->d_un.d_val & DF_1_CONFALT) 20217c478bd9Sstevel@tonic-gate crle = 1; 202256deab07SRod Evans if (dyn->d_un.d_val & DF_1_DIRECT) 20239a411307Srie FLAGS1(lmp) |= FL1_RT_DIRECT; 202456deab07SRod Evans if (dyn->d_un.d_val & DF_1_NODEFLIB) 20257c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_NODEFLIB; 202656deab07SRod Evans if (dyn->d_un.d_val & DF_1_ENDFILTEE) 20277c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_ENDFILTE; 202856deab07SRod Evans if (dyn->d_un.d_val & DF_1_TRANS) 20297c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_TRANS; 203056deab07SRod Evans 20317247f888Srie /* 20327247f888Srie * Global auditing is only meaningful when 20337247f888Srie * specified by the initiating object of the 20347247f888Srie * process - typically the dynamic executable. 203508278a5eSRod Evans * If this is the initiating object, its link- 20367247f888Srie * map will not yet have been added to the 20377247f888Srie * link-map list, and consequently the link-map 20387247f888Srie * list is empty. (see setup()). 20397247f888Srie */ 204056deab07SRod Evans if (dyn->d_un.d_val & DF_1_GLOBAUDIT) { 2041481bba9eSRod Evans if (lml_main.lm_head == NULL) 20427247f888Srie FLAGS1(lmp) |= FL1_RT_GLOBAUD; 20437247f888Srie else 20447247f888Srie DBG_CALL(Dbg_audit_ignore(lmp)); 20457247f888Srie } 20467247f888Srie 20477c478bd9Sstevel@tonic-gate /* 20487c478bd9Sstevel@tonic-gate * If this object identifies itself as an 20497c478bd9Sstevel@tonic-gate * interposer, but relocation processing has 20507c478bd9Sstevel@tonic-gate * already started, then demote it. It's too 20517c478bd9Sstevel@tonic-gate * late to guarantee complete interposition. 20527c478bd9Sstevel@tonic-gate */ 2053a953e2b1Srie /* BEGIN CSTYLED */ 205456deab07SRod Evans if (dyn->d_un.d_val & 20559a411307Srie (DF_1_INTERPOSE | DF_1_SYMINTPOSE)) { 20569a411307Srie if (lml->lm_flags & LML_FLG_STARTREL) { 20575aefb655Srie DBG_CALL(Dbg_util_intoolate(lmp)); 20587c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) 20597c478bd9Sstevel@tonic-gate (void) printf( 20607c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_REL_ERR2), 20617c478bd9Sstevel@tonic-gate NAME(lmp)); 206256deab07SRod Evans } else if (dyn->d_un.d_val & DF_1_INTERPOSE) 20639a411307Srie FLAGS(lmp) |= FLG_RT_OBJINTPO; 20649a411307Srie else 20659a411307Srie FLAGS(lmp) |= FLG_RT_SYMINTPO; 20667c478bd9Sstevel@tonic-gate } 2067a953e2b1Srie /* END CSTYLED */ 20687c478bd9Sstevel@tonic-gate break; 20697c478bd9Sstevel@tonic-gate case DT_SYMINFO: 207056deab07SRod Evans SYMINFO(lmp) = (Syminfo *)(dyn->d_un.d_ptr + 20717c478bd9Sstevel@tonic-gate base); 20727c478bd9Sstevel@tonic-gate break; 20737c478bd9Sstevel@tonic-gate case DT_SYMINENT: 207456deab07SRod Evans SYMINENT(lmp) = dyn->d_un.d_val; 20757c478bd9Sstevel@tonic-gate break; 20767c478bd9Sstevel@tonic-gate case DT_PLTPAD: 207756deab07SRod Evans PLTPAD(lmp) = (void *)(dyn->d_un.d_ptr + base); 20787c478bd9Sstevel@tonic-gate break; 20797c478bd9Sstevel@tonic-gate case DT_PLTPADSZ: 208056deab07SRod Evans pltpadsz = dyn->d_un.d_val; 20817c478bd9Sstevel@tonic-gate break; 20827c478bd9Sstevel@tonic-gate case DT_SUNW_RTLDINF: 20837c478bd9Sstevel@tonic-gate /* 208410a4fa49Srie * Maintain a list of RTLDINFO structures. 208510a4fa49Srie * Typically, libc is the only supplier, and 208610a4fa49Srie * only one structure is provided. However, 208710a4fa49Srie * multiple suppliers and multiple structures 208810a4fa49Srie * are supported. For example, one structure 208910a4fa49Srie * may provide thread_init, and another 209010a4fa49Srie * structure may provide atexit reservations. 20917c478bd9Sstevel@tonic-gate */ 2092dde769a2SRod Evans if ((rti = alist_append(&lml->lm_rti, NULL, 209356deab07SRod Evans sizeof (Rti_desc), 209456deab07SRod Evans AL_CNT_RTLDINFO)) == NULL) { 20952020b2b6SRod Evans remove_so(0, lmp, clmp); 209656deab07SRod Evans return (NULL); 20977c478bd9Sstevel@tonic-gate } 209810a4fa49Srie rti->rti_lmp = lmp; 209956deab07SRod Evans rti->rti_info = (void *)(dyn->d_un.d_ptr + 210056deab07SRod Evans base); 21017c478bd9Sstevel@tonic-gate break; 2102d579eb63Sab case DT_SUNW_SORTENT: 210356deab07SRod Evans SUNWSORTENT(lmp) = dyn->d_un.d_val; 2104d579eb63Sab break; 2105d579eb63Sab case DT_SUNW_SYMSORT: 2106d579eb63Sab SUNWSYMSORT(lmp) = 210756deab07SRod Evans (void *)(dyn->d_un.d_ptr + base); 2108d579eb63Sab break; 2109d579eb63Sab case DT_SUNW_SYMSORTSZ: 211056deab07SRod Evans SUNWSYMSORTSZ(lmp) = dyn->d_un.d_val; 2111d579eb63Sab break; 21127c478bd9Sstevel@tonic-gate case DT_DEPRECATED_SPARC_REGISTER: 21137c478bd9Sstevel@tonic-gate case M_DT_REGISTER: 2114f441771bSRod Evans dip->di_flags |= FLG_DI_REGISTER; 21157c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_REGSYMS; 21167c478bd9Sstevel@tonic-gate break; 211708278a5eSRod Evans case DT_SUNW_CAP: 211808278a5eSRod Evans CAP(lmp) = (void *)(dyn->d_un.d_ptr + base); 211908278a5eSRod Evans break; 212008278a5eSRod Evans case DT_SUNW_CAPINFO: 212108278a5eSRod Evans CAPINFO(lmp) = (void *)(dyn->d_un.d_ptr + base); 212208278a5eSRod Evans break; 212308278a5eSRod Evans case DT_SUNW_CAPCHAIN: 212408278a5eSRod Evans CAPCHAIN(lmp) = (void *)(dyn->d_un.d_ptr + 212508278a5eSRod Evans base); 212608278a5eSRod Evans break; 212708278a5eSRod Evans case DT_SUNW_CAPCHAINENT: 212808278a5eSRod Evans CAPCHAINENT(lmp) = dyn->d_un.d_val; 212908278a5eSRod Evans break; 213008278a5eSRod Evans case DT_SUNW_CAPCHAINSZ: 213108278a5eSRod Evans CAPCHAINSZ(lmp) = dyn->d_un.d_val; 213208278a5eSRod Evans break; 21337c478bd9Sstevel@tonic-gate } 21347c478bd9Sstevel@tonic-gate } 21357c478bd9Sstevel@tonic-gate 2136f441771bSRod Evans /* 2137f441771bSRod Evans * Update any Dyninfo string pointers now that STRTAB() is 2138f441771bSRod Evans * known. 2139f441771bSRod Evans */ 2140f441771bSRod Evans for (dynndx = 0, dyn = DYN(lmp), dip = DYNINFO(lmp); 2141f441771bSRod Evans !(dip->di_flags & FLG_DI_IGNORE); dyn++, dip++) { 2142f441771bSRod Evans 2143f441771bSRod Evans switch ((Xword)dyn->d_tag) { 2144f441771bSRod Evans case DT_NEEDED: 2145f441771bSRod Evans case DT_USED: 2146f441771bSRod Evans case DT_FILTER: 2147f441771bSRod Evans case DT_AUXILIARY: 2148f441771bSRod Evans case DT_SUNW_FILTER: 2149f441771bSRod Evans case DT_SUNW_AUXILIARY: 2150f441771bSRod Evans dip->di_name = STRTAB(lmp) + dyn->d_un.d_val; 2151f441771bSRod Evans break; 2152f441771bSRod Evans } 2153f441771bSRod Evans } 2154f441771bSRod Evans 2155f441771bSRod Evans /* 2156f441771bSRod Evans * Assign any padding. 2157f441771bSRod Evans */ 21587c478bd9Sstevel@tonic-gate if (PLTPAD(lmp)) { 21597c478bd9Sstevel@tonic-gate if (pltpadsz == (Xword)0) 2160481bba9eSRod Evans PLTPAD(lmp) = NULL; 21617c478bd9Sstevel@tonic-gate else 21627c478bd9Sstevel@tonic-gate PLTPADEND(lmp) = (void *)((Addr)PLTPAD(lmp) + 21637c478bd9Sstevel@tonic-gate pltpadsz); 21647c478bd9Sstevel@tonic-gate } 21657c478bd9Sstevel@tonic-gate } 21667c478bd9Sstevel@tonic-gate 21679039eeafSab /* 21689039eeafSab * A dynsym contains only global functions. We want to have 21699039eeafSab * a version of it that also includes local functions, so that 21709039eeafSab * dladdr() will be able to report names for local functions 21719039eeafSab * when used to generate a stack trace for a stripped file. 21729039eeafSab * This version of the dynsym is provided via DT_SUNW_SYMTAB. 21739039eeafSab * 21749039eeafSab * In producing DT_SUNW_SYMTAB, ld uses a non-obvious trick 21759039eeafSab * in order to avoid having to have two copies of the global 21769039eeafSab * symbols held in DT_SYMTAB: The local symbols are placed in 21779039eeafSab * a separate section than the globals in the dynsym, but the 21789039eeafSab * linker conspires to put the data for these two sections adjacent 21799039eeafSab * to each other. DT_SUNW_SYMTAB points at the top of the local 21809039eeafSab * symbols, and DT_SUNW_SYMSZ is the combined length of both tables. 21819039eeafSab * 21829039eeafSab * If the two sections are not adjacent, then something went wrong 21839039eeafSab * at link time. We use ASSERT to kill the process if this is 21849039eeafSab * a debug build. In a production build, we will silently ignore 21859039eeafSab * the presence of the .ldynsym and proceed. We can detect this 21869039eeafSab * situation by checking to see that DT_SYMTAB lies in 21879039eeafSab * the range given by DT_SUNW_SYMTAB/DT_SUNW_SYMSZ. 21889039eeafSab */ 21899039eeafSab if ((SUNWSYMTAB(lmp) != NULL) && 21909039eeafSab (((char *)SYMTAB(lmp) <= (char *)SUNWSYMTAB(lmp)) || 21919039eeafSab (((char *)SYMTAB(lmp) >= 21929039eeafSab (SUNWSYMSZ(lmp) + (char *)SUNWSYMTAB(lmp)))))) { 21939039eeafSab ASSERT(0); 21949039eeafSab SUNWSYMTAB(lmp) = NULL; 21959039eeafSab SUNWSYMSZ(lmp) = 0; 21969039eeafSab } 21979039eeafSab 21987c478bd9Sstevel@tonic-gate /* 21997c478bd9Sstevel@tonic-gate * If configuration file use hasn't been disabled, and a configuration 22007c478bd9Sstevel@tonic-gate * file hasn't already been set via an environment variable, see if any 22017c478bd9Sstevel@tonic-gate * application specific configuration file is specified. An LD_CONFIG 22027c478bd9Sstevel@tonic-gate * setting is used first, but if this image was generated via crle(1) 22037c478bd9Sstevel@tonic-gate * then a default configuration file is a fall-back. 22047c478bd9Sstevel@tonic-gate */ 2205481bba9eSRod Evans if ((!(rtld_flags & RT_FL_NOCFG)) && (config->c_name == NULL)) { 22067c478bd9Sstevel@tonic-gate if (cfile) 22077c478bd9Sstevel@tonic-gate config->c_name = (const char *)(cfile + 22087c478bd9Sstevel@tonic-gate (char *)STRTAB(lmp)); 220956deab07SRod Evans else if (crle) 22107c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_CONFAPP; 22117c478bd9Sstevel@tonic-gate } 22127c478bd9Sstevel@tonic-gate 22137c478bd9Sstevel@tonic-gate if (rpath) 22147c478bd9Sstevel@tonic-gate RPATH(lmp) = (char *)(rpath + (char *)STRTAB(lmp)); 221556deab07SRod Evans if (fltr) 221656deab07SRod Evans REFNAME(lmp) = (char *)(fltr + (char *)STRTAB(lmp)); 22177c478bd9Sstevel@tonic-gate 22187c478bd9Sstevel@tonic-gate /* 22197c478bd9Sstevel@tonic-gate * For Intel ABI compatibility. It's possible that a JMPREL can be 22207c478bd9Sstevel@tonic-gate * specified without any other relocations (e.g. a dynamic executable 22217c478bd9Sstevel@tonic-gate * normally only contains .plt relocations). If this is the case then 22227c478bd9Sstevel@tonic-gate * no REL, RELSZ or RELENT will have been created. For us to be able 22237c478bd9Sstevel@tonic-gate * to traverse the .plt relocations under LD_BIND_NOW we need to know 22247c478bd9Sstevel@tonic-gate * the RELENT for these relocations. Refer to elf_reloc() for more 22257c478bd9Sstevel@tonic-gate * details. 22267c478bd9Sstevel@tonic-gate */ 22277c478bd9Sstevel@tonic-gate if (!RELENT(lmp) && JMPREL(lmp)) 222856deab07SRod Evans RELENT(lmp) = sizeof (M_RELOC); 22297c478bd9Sstevel@tonic-gate 22307c478bd9Sstevel@tonic-gate /* 2231f441771bSRod Evans * Establish any per-object auditing. If we're establishing main's 22327c478bd9Sstevel@tonic-gate * link-map its too early to go searching for audit objects so just 22337c478bd9Sstevel@tonic-gate * hold the object name for later (see setup()). 22347c478bd9Sstevel@tonic-gate */ 22357c478bd9Sstevel@tonic-gate if (audit) { 22367c478bd9Sstevel@tonic-gate char *cp = audit + (char *)STRTAB(lmp); 22377c478bd9Sstevel@tonic-gate 22387c478bd9Sstevel@tonic-gate if (*cp) { 22397c478bd9Sstevel@tonic-gate if (((AUDITORS(lmp) = 224056deab07SRod Evans calloc(1, sizeof (Audit_desc))) == NULL) || 224156deab07SRod Evans ((AUDITORS(lmp)->ad_name = strdup(cp)) == NULL)) { 22422020b2b6SRod Evans remove_so(0, lmp, clmp); 224356deab07SRod Evans return (NULL); 22447c478bd9Sstevel@tonic-gate } 224541072f3cSrie if (lml_main.lm_head) { 22469aa23310Srie if (audit_setup(lmp, AUDITORS(lmp), 0, 22479aa23310Srie in_nfavl) == 0) { 22482020b2b6SRod Evans remove_so(0, lmp, clmp); 224956deab07SRod Evans return (NULL); 22507c478bd9Sstevel@tonic-gate } 225156deab07SRod Evans AFLAGS(lmp) |= AUDITORS(lmp)->ad_flags; 22527c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_LOCAUDIT; 22537c478bd9Sstevel@tonic-gate } 22547c478bd9Sstevel@tonic-gate } 22557c478bd9Sstevel@tonic-gate } 22567c478bd9Sstevel@tonic-gate 225756deab07SRod Evans if (tphdr && (tls_assign(lml, lmp, tphdr) == 0)) { 22582020b2b6SRod Evans remove_so(0, lmp, clmp); 225956deab07SRod Evans return (NULL); 22607c478bd9Sstevel@tonic-gate } 22617c478bd9Sstevel@tonic-gate 226208278a5eSRod Evans /* 226308278a5eSRod Evans * A capabilities section should be identified by a DT_SUNW_CAP entry, 226408278a5eSRod Evans * and if non-empty object capabilities are included, a PT_SUNWCAP 226508278a5eSRod Evans * header should reference the section. Make sure CAP() is set 226608278a5eSRod Evans * regardless. 226708278a5eSRod Evans */ 226808278a5eSRod Evans if ((CAP(lmp) == NULL) && cap) 226908278a5eSRod Evans CAP(lmp) = cap; 227008278a5eSRod Evans 227108278a5eSRod Evans /* 227208278a5eSRod Evans * Make sure any capabilities information or chain can be handled. 227308278a5eSRod Evans */ 227408278a5eSRod Evans if (CAPINFO(lmp) && (CAPINFO(lmp)[0] > CAPINFO_CURRENT)) 227508278a5eSRod Evans CAPINFO(lmp) = NULL; 227608278a5eSRod Evans if (CAPCHAIN(lmp) && (CAPCHAIN(lmp)[0] > CAPCHAIN_CURRENT)) 227708278a5eSRod Evans CAPCHAIN(lmp) = NULL; 227808278a5eSRod Evans 227908278a5eSRod Evans /* 228008278a5eSRod Evans * As part of processing dependencies, a file descriptor is populated 228108278a5eSRod Evans * with capabilities information following validation. 228208278a5eSRod Evans */ 228308278a5eSRod Evans if (fdp->fd_flags & FLG_FD_ALTCHECK) { 228408278a5eSRod Evans FLAGS1(lmp) |= FL1_RT_ALTCHECK; 228508278a5eSRod Evans CAPSET(lmp) = fdp->fd_scapset; 228608278a5eSRod Evans 228708278a5eSRod Evans if (fdp->fd_flags & FLG_FD_ALTCAP) 228808278a5eSRod Evans FLAGS1(lmp) |= FL1_RT_ALTCAP; 228908278a5eSRod Evans 229008278a5eSRod Evans } else if ((cap = CAP(lmp)) != NULL) { 229108278a5eSRod Evans /* 229208278a5eSRod Evans * Processing of the a.out and ld.so.1 does not involve a file 229308278a5eSRod Evans * descriptor as exec() did all the work, so capture the 229408278a5eSRod Evans * capabilities for these cases. 229508278a5eSRod Evans */ 229608278a5eSRod Evans while (cap->c_tag != CA_SUNW_NULL) { 229708278a5eSRod Evans switch (cap->c_tag) { 229808278a5eSRod Evans case CA_SUNW_HW_1: 229908278a5eSRod Evans CAPSET(lmp).sc_hw_1 = cap->c_un.c_val; 230008278a5eSRod Evans break; 230108278a5eSRod Evans case CA_SUNW_SF_1: 230208278a5eSRod Evans CAPSET(lmp).sc_sf_1 = cap->c_un.c_val; 230308278a5eSRod Evans break; 230408278a5eSRod Evans case CA_SUNW_HW_2: 230508278a5eSRod Evans CAPSET(lmp).sc_hw_2 = cap->c_un.c_val; 230608278a5eSRod Evans break; 230708278a5eSRod Evans case CA_SUNW_PLAT: 230808278a5eSRod Evans CAPSET(lmp).sc_plat = STRTAB(lmp) + 230908278a5eSRod Evans cap->c_un.c_ptr; 231008278a5eSRod Evans break; 231108278a5eSRod Evans case CA_SUNW_MACH: 231208278a5eSRod Evans CAPSET(lmp).sc_mach = STRTAB(lmp) + 231308278a5eSRod Evans cap->c_un.c_ptr; 231408278a5eSRod Evans break; 231508278a5eSRod Evans } 231608278a5eSRod Evans cap++; 231708278a5eSRod Evans } 231808278a5eSRod Evans } 231908278a5eSRod Evans 232008278a5eSRod Evans /* 232108278a5eSRod Evans * If a capabilities chain table exists, duplicate it. The chain table 232208278a5eSRod Evans * is inspected for each initial call to a capabilities family lead 232308278a5eSRod Evans * symbol. From this chain, each family member is inspected to 232408278a5eSRod Evans * determine the 'best' family member. The chain table is then updated 232508278a5eSRod Evans * so that the best member is immediately selected for any further 232608278a5eSRod Evans * family searches. 232708278a5eSRod Evans */ 232808278a5eSRod Evans if (CAPCHAIN(lmp)) { 232908278a5eSRod Evans Capchain *capchain; 233008278a5eSRod Evans 233108278a5eSRod Evans if ((capchain = calloc(CAPCHAINSZ(lmp), 1)) == NULL) 233208278a5eSRod Evans return (NULL); 233308278a5eSRod Evans (void) memcpy(capchain, CAPCHAIN(lmp), CAPCHAINSZ(lmp)); 233408278a5eSRod Evans CAPCHAIN(lmp) = capchain; 233508278a5eSRod Evans } 233656deab07SRod Evans 23377c478bd9Sstevel@tonic-gate /* 23387c478bd9Sstevel@tonic-gate * Add the mapped object to the end of the link map list. 23397c478bd9Sstevel@tonic-gate */ 23407c478bd9Sstevel@tonic-gate lm_append(lml, lmco, lmp); 234156deab07SRod Evans 234256deab07SRod Evans /* 234356deab07SRod Evans * Start the system loading in the ELF information we'll be processing. 234456deab07SRod Evans */ 234556deab07SRod Evans if (REL(lmp)) { 234656deab07SRod Evans (void) madvise((void *)ADDR(lmp), (uintptr_t)REL(lmp) + 234756deab07SRod Evans (uintptr_t)RELSZ(lmp) - (uintptr_t)ADDR(lmp), 234856deab07SRod Evans MADV_WILLNEED); 234956deab07SRod Evans } 23507c478bd9Sstevel@tonic-gate return (lmp); 23517c478bd9Sstevel@tonic-gate } 23527c478bd9Sstevel@tonic-gate 23537c478bd9Sstevel@tonic-gate /* 23547c478bd9Sstevel@tonic-gate * Build full pathname of shared object from given directory name and filename. 23557c478bd9Sstevel@tonic-gate */ 23567c478bd9Sstevel@tonic-gate static char * 235756deab07SRod Evans elf_get_so(const char *dir, const char *file, size_t dlen, size_t flen) 23587c478bd9Sstevel@tonic-gate { 23597c478bd9Sstevel@tonic-gate static char pname[PATH_MAX]; 23607c478bd9Sstevel@tonic-gate 236156deab07SRod Evans (void) strncpy(pname, dir, dlen); 236256deab07SRod Evans pname[dlen++] = '/'; 236356deab07SRod Evans (void) strncpy(&pname[dlen], file, flen + 1); 23647c478bd9Sstevel@tonic-gate return (pname); 23657c478bd9Sstevel@tonic-gate } 23667c478bd9Sstevel@tonic-gate 23677c478bd9Sstevel@tonic-gate /* 23687c478bd9Sstevel@tonic-gate * The copy relocation is recorded in a copy structure which will be applied 23697c478bd9Sstevel@tonic-gate * after all other relocations are carried out. This provides for copying data 23707c478bd9Sstevel@tonic-gate * that must be relocated itself (ie. pointers in shared objects). This 23717c478bd9Sstevel@tonic-gate * structure also provides a means of binding RTLD_GROUP dependencies to any 23727c478bd9Sstevel@tonic-gate * copy relocations that have been taken from any group members. 23737c478bd9Sstevel@tonic-gate * 23747c478bd9Sstevel@tonic-gate * If the size of the .bss area available for the copy information is not the 23757c478bd9Sstevel@tonic-gate * same as the source of the data inform the user if we're under ldd(1) control 23767c478bd9Sstevel@tonic-gate * (this checking was only established in 5.3, so by only issuing an error via 23777c478bd9Sstevel@tonic-gate * ldd(1) we maintain the standard set by previous releases). 23787c478bd9Sstevel@tonic-gate */ 23797c478bd9Sstevel@tonic-gate int 23807c478bd9Sstevel@tonic-gate elf_copy_reloc(char *name, Sym *rsym, Rt_map *rlmp, void *radd, Sym *dsym, 23817c478bd9Sstevel@tonic-gate Rt_map *dlmp, const void *dadd) 23827c478bd9Sstevel@tonic-gate { 23837c478bd9Sstevel@tonic-gate Rel_copy rc; 23847c478bd9Sstevel@tonic-gate Lm_list *lml = LIST(rlmp); 23857c478bd9Sstevel@tonic-gate 23867c478bd9Sstevel@tonic-gate rc.r_name = name; 23877c478bd9Sstevel@tonic-gate rc.r_rsym = rsym; /* the new reference symbol and its */ 23887c478bd9Sstevel@tonic-gate rc.r_rlmp = rlmp; /* associated link-map */ 23897c478bd9Sstevel@tonic-gate rc.r_dlmp = dlmp; /* the defining link-map */ 23907c478bd9Sstevel@tonic-gate rc.r_dsym = dsym; /* the original definition */ 23917c478bd9Sstevel@tonic-gate rc.r_radd = radd; 23927c478bd9Sstevel@tonic-gate rc.r_dadd = dadd; 23937c478bd9Sstevel@tonic-gate 23947c478bd9Sstevel@tonic-gate if (rsym->st_size > dsym->st_size) 23957c478bd9Sstevel@tonic-gate rc.r_size = (size_t)dsym->st_size; 23967c478bd9Sstevel@tonic-gate else 23977c478bd9Sstevel@tonic-gate rc.r_size = (size_t)rsym->st_size; 23987c478bd9Sstevel@tonic-gate 2399cce0e03bSab if (alist_append(©_R(dlmp), &rc, sizeof (Rel_copy), 240056deab07SRod Evans AL_CNT_COPYREL) == NULL) { 24017c478bd9Sstevel@tonic-gate if (!(lml->lm_flags & LML_FLG_TRC_WARN)) 24027c478bd9Sstevel@tonic-gate return (0); 24037c478bd9Sstevel@tonic-gate else 24047c478bd9Sstevel@tonic-gate return (1); 24057c478bd9Sstevel@tonic-gate } 24067c478bd9Sstevel@tonic-gate if (!(FLAGS1(dlmp) & FL1_RT_COPYTOOK)) { 2407cce0e03bSab if (aplist_append(©_S(rlmp), dlmp, 2408cce0e03bSab AL_CNT_COPYREL) == NULL) { 24097c478bd9Sstevel@tonic-gate if (!(lml->lm_flags & LML_FLG_TRC_WARN)) 24107c478bd9Sstevel@tonic-gate return (0); 24117c478bd9Sstevel@tonic-gate else 24127c478bd9Sstevel@tonic-gate return (1); 24137c478bd9Sstevel@tonic-gate } 24147c478bd9Sstevel@tonic-gate FLAGS1(dlmp) |= FL1_RT_COPYTOOK; 24157c478bd9Sstevel@tonic-gate } 24167c478bd9Sstevel@tonic-gate 24177c478bd9Sstevel@tonic-gate /* 24187c478bd9Sstevel@tonic-gate * If we are tracing (ldd), warn the user if 24197c478bd9Sstevel@tonic-gate * 1) the size from the reference symbol differs from the 24207c478bd9Sstevel@tonic-gate * copy definition. We can only copy as much data as the 24217c478bd9Sstevel@tonic-gate * reference (dynamic executables) entry allows. 24227c478bd9Sstevel@tonic-gate * 2) the copy definition has STV_PROTECTED visibility. 24237c478bd9Sstevel@tonic-gate */ 24247c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_WARN) { 24257c478bd9Sstevel@tonic-gate if (rsym->st_size != dsym->st_size) { 24267c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_CPY_SIZDIF), 24275aefb655Srie _conv_reloc_type(M_R_COPY), demangle(name), 24287c478bd9Sstevel@tonic-gate NAME(rlmp), EC_XWORD(rsym->st_size), 24297c478bd9Sstevel@tonic-gate NAME(dlmp), EC_XWORD(dsym->st_size)); 24307c478bd9Sstevel@tonic-gate if (rsym->st_size > dsym->st_size) 24317c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_CPY_INSDATA), 24327c478bd9Sstevel@tonic-gate NAME(dlmp)); 24337c478bd9Sstevel@tonic-gate else 24347c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_CPY_DATRUNC), 24357c478bd9Sstevel@tonic-gate NAME(rlmp)); 24367c478bd9Sstevel@tonic-gate } 24377c478bd9Sstevel@tonic-gate 24387c478bd9Sstevel@tonic-gate if (ELF_ST_VISIBILITY(dsym->st_other) == STV_PROTECTED) { 24397c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_CPY_PROT), 24405aefb655Srie _conv_reloc_type(M_R_COPY), demangle(name), 2441a953e2b1Srie NAME(dlmp)); 24427c478bd9Sstevel@tonic-gate } 24437c478bd9Sstevel@tonic-gate } 24447c478bd9Sstevel@tonic-gate 24455aefb655Srie DBG_CALL(Dbg_reloc_apply_val(lml, ELF_DBG_RTLD, (Xword)radd, 24465aefb655Srie (Xword)rc.r_size)); 24477c478bd9Sstevel@tonic-gate return (1); 24487c478bd9Sstevel@tonic-gate } 24497c478bd9Sstevel@tonic-gate 24507c478bd9Sstevel@tonic-gate /* 24517c478bd9Sstevel@tonic-gate * Determine the symbol location of an address within a link-map. Look for 24527c478bd9Sstevel@tonic-gate * the nearest symbol (whose value is less than or equal to the required 24537c478bd9Sstevel@tonic-gate * address). This is the object specific part of dladdr(). 24547c478bd9Sstevel@tonic-gate */ 24557c478bd9Sstevel@tonic-gate static void 24567c478bd9Sstevel@tonic-gate elf_dladdr(ulong_t addr, Rt_map *lmp, Dl_info *dlip, void **info, int flags) 24577c478bd9Sstevel@tonic-gate { 24587c478bd9Sstevel@tonic-gate ulong_t ndx, cnt, base, _value; 24596221fe92Sab Sym *sym, *_sym = NULL; 24607c478bd9Sstevel@tonic-gate const char *str; 24615343e1b3Sab int _flags; 2462d579eb63Sab uint_t *dynaddr_ndx; 2463d579eb63Sab uint_t dynaddr_n = 0; 2464d579eb63Sab ulong_t value; 24657c478bd9Sstevel@tonic-gate 24667c478bd9Sstevel@tonic-gate /* 24679039eeafSab * If SUNWSYMTAB() is non-NULL, then it sees a special version of 24689039eeafSab * the dynsym that starts with any local function symbols that exist in 24699039eeafSab * the library and then moves to the data held in SYMTAB(). In this 24709039eeafSab * case, SUNWSYMSZ tells us how long the symbol table is. The 24719039eeafSab * availability of local function symbols will enhance the results 24729039eeafSab * we can provide. 24739039eeafSab * 2474d579eb63Sab * If SUNWSYMTAB() is non-NULL, then there might also be a 2475d579eb63Sab * SUNWSYMSORT() vector associated with it. SUNWSYMSORT() contains 2476d579eb63Sab * an array of indices into SUNWSYMTAB, sorted by increasing 2477d579eb63Sab * address. We can use this to do an O(log N) search instead of a 2478d579eb63Sab * brute force search. 2479d579eb63Sab * 24809039eeafSab * If SUNWSYMTAB() is NULL, then SYMTAB() references a dynsym that 24819039eeafSab * contains only global symbols. In that case, the length of 24829039eeafSab * the symbol table comes from the nchain field of the related 24839039eeafSab * symbol lookup hash table. 24847c478bd9Sstevel@tonic-gate */ 24857c478bd9Sstevel@tonic-gate str = STRTAB(lmp); 248667d74cc3SToomas Soome if (SUNWSYMSZ(lmp) == 0) { 24879039eeafSab sym = SYMTAB(lmp); 24889039eeafSab /* 24899039eeafSab * If we don't have a .hash table there are no symbols 24909039eeafSab * to look at. 24919039eeafSab */ 2492481bba9eSRod Evans if (HASH(lmp) == NULL) 24939039eeafSab return; 24949039eeafSab cnt = HASH(lmp)[1]; 24959039eeafSab } else { 24969039eeafSab sym = SUNWSYMTAB(lmp); 24979039eeafSab cnt = SUNWSYMSZ(lmp) / SYMENT(lmp); 2498d579eb63Sab dynaddr_ndx = SUNWSYMSORT(lmp); 2499d579eb63Sab if (dynaddr_ndx != NULL) 2500d579eb63Sab dynaddr_n = SUNWSYMSORTSZ(lmp) / SUNWSORTENT(lmp); 25019039eeafSab } 25027c478bd9Sstevel@tonic-gate 25037c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_FIXED) 25047c478bd9Sstevel@tonic-gate base = 0; 25057c478bd9Sstevel@tonic-gate else 25067c478bd9Sstevel@tonic-gate base = ADDR(lmp); 25077c478bd9Sstevel@tonic-gate 2508d579eb63Sab if (dynaddr_n > 0) { /* Binary search */ 2509d579eb63Sab long low = 0, low_bnd; 2510d579eb63Sab long high = dynaddr_n - 1, high_bnd; 2511d579eb63Sab long mid; 2512d579eb63Sab Sym *mid_sym; 25137c478bd9Sstevel@tonic-gate 25149039eeafSab /* 2515d579eb63Sab * Note that SUNWSYMSORT only contains symbols types that 2516d579eb63Sab * supply memory addresses, so there's no need to check and 2517d579eb63Sab * filter out any other types. 25189039eeafSab */ 2519d579eb63Sab low_bnd = low; 2520d579eb63Sab high_bnd = high; 2521d579eb63Sab while (low <= high) { 2522d579eb63Sab mid = (low + high) / 2; 2523d579eb63Sab mid_sym = &sym[dynaddr_ndx[mid]]; 2524d579eb63Sab value = mid_sym->st_value + base; 2525d579eb63Sab if (addr < value) { 2526d579eb63Sab if ((sym[dynaddr_ndx[high]].st_value + base) >= 2527d579eb63Sab addr) 2528d579eb63Sab high_bnd = high; 2529d579eb63Sab high = mid - 1; 2530d579eb63Sab } else if (addr > value) { 2531d579eb63Sab if ((sym[dynaddr_ndx[low]].st_value + base) <= 2532d579eb63Sab addr) 2533d579eb63Sab low_bnd = low; 2534d579eb63Sab low = mid + 1; 2535d579eb63Sab } else { 2536d579eb63Sab _sym = mid_sym; 2537d579eb63Sab _value = value; 2538d579eb63Sab break; 2539d579eb63Sab } 2540d579eb63Sab } 2541d579eb63Sab /* 2542d579eb63Sab * If the above didn't find it exactly, then we must 2543d579eb63Sab * return the closest symbol with a value that doesn't 2544d579eb63Sab * exceed the one we are looking for. If that symbol exists, 2545d579eb63Sab * it will lie in the range bounded by low_bnd and 2546d579eb63Sab * high_bnd. This is a linear search, but a short one. 2547d579eb63Sab */ 2548d579eb63Sab if (_sym == NULL) { 2549d579eb63Sab for (mid = low_bnd; mid <= high_bnd; mid++) { 2550d579eb63Sab mid_sym = &sym[dynaddr_ndx[mid]]; 2551d579eb63Sab value = mid_sym->st_value + base; 2552d579eb63Sab if (addr >= value) { 2553d579eb63Sab _sym = mid_sym; 2554d579eb63Sab _value = value; 2555d579eb63Sab } else { 2556d579eb63Sab break; 2557d579eb63Sab } 2558d579eb63Sab } 2559d579eb63Sab } 2560d579eb63Sab } else { /* Linear search */ 2561d579eb63Sab for (_value = 0, sym++, ndx = 1; ndx < cnt; ndx++, sym++) { 2562d579eb63Sab /* 2563d579eb63Sab * Skip expected symbol types that are not functions 2564d579eb63Sab * or data: 2565d579eb63Sab * - A symbol table starts with an undefined symbol 2566d579eb63Sab * in slot 0. If we are using SUNWSYMTAB(), 2567d579eb63Sab * there will be a second undefined symbol 2568d579eb63Sab * right before the globals. 2569d579eb63Sab * - The local part of SUNWSYMTAB() contains a 2570d579eb63Sab * series of function symbols. Each section 2571d579eb63Sab * starts with an initial STT_FILE symbol. 2572d579eb63Sab */ 2573d579eb63Sab if ((sym->st_shndx == SHN_UNDEF) || 2574d579eb63Sab (ELF_ST_TYPE(sym->st_info) == STT_FILE)) 2575d579eb63Sab continue; 25767c478bd9Sstevel@tonic-gate 2577d579eb63Sab value = sym->st_value + base; 2578d579eb63Sab if (value > addr) 2579d579eb63Sab continue; 2580d579eb63Sab if (value < _value) 2581d579eb63Sab continue; 25827c478bd9Sstevel@tonic-gate 2583d579eb63Sab _sym = sym; 2584d579eb63Sab _value = value; 25857c478bd9Sstevel@tonic-gate 2586d579eb63Sab /* 2587d579eb63Sab * Note, because we accept local and global symbols 2588d579eb63Sab * we could find a section symbol that matches the 2589d579eb63Sab * associated address, which means that the symbol 2590d579eb63Sab * name will be null. In this case continue the 2591d579eb63Sab * search in case we can find a global symbol of 2592d579eb63Sab * the same value. 2593d579eb63Sab */ 2594d579eb63Sab if ((value == addr) && 2595d579eb63Sab (ELF_ST_TYPE(sym->st_info) != STT_SECTION)) 2596d579eb63Sab break; 2597d579eb63Sab } 25987c478bd9Sstevel@tonic-gate } 25997c478bd9Sstevel@tonic-gate 26005343e1b3Sab _flags = flags & RTLD_DL_MASK; 26017c478bd9Sstevel@tonic-gate if (_sym) { 26027c478bd9Sstevel@tonic-gate if (_flags == RTLD_DL_SYMENT) 26037c478bd9Sstevel@tonic-gate *info = (void *)_sym; 26047c478bd9Sstevel@tonic-gate else if (_flags == RTLD_DL_LINKMAP) 26057c478bd9Sstevel@tonic-gate *info = (void *)lmp; 26067c478bd9Sstevel@tonic-gate 26077c478bd9Sstevel@tonic-gate dlip->dli_sname = str + _sym->st_name; 26087c478bd9Sstevel@tonic-gate dlip->dli_saddr = (void *)_value; 26095343e1b3Sab } else { 26105343e1b3Sab /* 26115343e1b3Sab * addr lies between the beginning of the mapped segment and 26125343e1b3Sab * the first global symbol. We have no symbol to return 26135343e1b3Sab * and the caller requires one. We use _START_, the base 26145343e1b3Sab * address of the mapping. 26155343e1b3Sab */ 26165343e1b3Sab 26175343e1b3Sab if (_flags == RTLD_DL_SYMENT) { 26185343e1b3Sab /* 26195343e1b3Sab * An actual symbol struct is needed, so we 26205343e1b3Sab * construct one for _START_. To do this in a 26215343e1b3Sab * fully accurate way requires a different symbol 26225343e1b3Sab * for each mapped segment. This requires the 26235343e1b3Sab * use of dynamic memory and a mutex. That's too much 26245343e1b3Sab * plumbing for a fringe case of limited importance. 26255343e1b3Sab * 26265343e1b3Sab * Fortunately, we can simplify: 26275343e1b3Sab * - Only the st_size and st_info fields are useful 26285343e1b3Sab * outside of the linker internals. The others 26295343e1b3Sab * reference things that outside code cannot see, 26305343e1b3Sab * and can be set to 0. 26315343e1b3Sab * - It's just a label and there is no size 26325343e1b3Sab * to report. So, the size should be 0. 26335343e1b3Sab * This means that only st_info needs a non-zero 26345343e1b3Sab * (constant) value. A static struct will suffice. 26355343e1b3Sab * It must be const (readonly) so the caller can't 26365343e1b3Sab * change its meaning for subsequent callers. 26375343e1b3Sab */ 26385343e1b3Sab static const Sym fsym = { 0, 0, 0, 263937ffaf83SRod Evans ELF_ST_INFO(STB_LOCAL, STT_OBJECT) }; 26405343e1b3Sab *info = (void *) &fsym; 26415343e1b3Sab } 26425343e1b3Sab 26435343e1b3Sab dlip->dli_sname = MSG_ORIG(MSG_SYM_START); 26445343e1b3Sab dlip->dli_saddr = (void *) ADDR(lmp); 26457c478bd9Sstevel@tonic-gate } 26467c478bd9Sstevel@tonic-gate } 26477c478bd9Sstevel@tonic-gate 26487c478bd9Sstevel@tonic-gate /* 264975e7992aSrie * This routine is called as a last fall-back to search for a symbol from a 26502017c965SRod Evans * standard relocation or dlsym(). To maintain lazy loadings goal of reducing 26512017c965SRod Evans * the number of objects mapped, any symbol search is first carried out using 26522017c965SRod Evans * the objects that already exist in the process (either on a link-map list or 26532017c965SRod Evans * handle). If a symbol can't be found, and lazy dependencies are still 26542017c965SRod Evans * pending, this routine loads the dependencies in an attempt to locate the 26552017c965SRod Evans * symbol. 26567c478bd9Sstevel@tonic-gate */ 265708278a5eSRod Evans int 265808278a5eSRod Evans elf_lazy_find_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl) 26597c478bd9Sstevel@tonic-gate { 26602017c965SRod Evans static APlist *alist = NULL; 26612017c965SRod Evans Aliste idx1; 26622017c965SRod Evans Rt_map *lmp1, *lmp = slp->sl_imap, *clmp = slp->sl_cmap; 26637c478bd9Sstevel@tonic-gate const char *name = slp->sl_name; 26642017c965SRod Evans Slookup sl1 = *slp; 26652017c965SRod Evans Lm_list *lml; 26662017c965SRod Evans Lm_cntl *lmc; 26672017c965SRod Evans 26682017c965SRod Evans /* 26692017c965SRod Evans * It's quite possible we've been here before to process objects, 26702017c965SRod Evans * therefore reinitialize our dynamic list. 26712017c965SRod Evans */ 26722017c965SRod Evans if (alist) 26732017c965SRod Evans aplist_reset(alist); 26742017c965SRod Evans 26752017c965SRod Evans /* 26762017c965SRod Evans * Discard any relocation index from further symbol searches. This 26772017c965SRod Evans * index has already been used to trigger any necessary lazy-loads, 26782017c965SRod Evans * and it might be because one of these lazy loads has failed that 26792017c965SRod Evans * we're performing this fallback. By removing the relocation index 26802017c965SRod Evans * we don't try and perform the same failed lazy loading activity again. 26812017c965SRod Evans */ 26822017c965SRod Evans sl1.sl_rsymndx = 0; 26832017c965SRod Evans 26842017c965SRod Evans /* 26852017c965SRod Evans * Determine the callers link-map list so that we can monitor whether 26862017c965SRod Evans * new objects have been added. 26872017c965SRod Evans */ 26882017c965SRod Evans lml = LIST(clmp); 26892017c965SRod Evans lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, CNTL(clmp)); 26907c478bd9Sstevel@tonic-gate 269175e7992aSrie /* 269275e7992aSrie * Generate a local list of new objects to process. This list can grow 269375e7992aSrie * as each object supplies its own lazy dependencies. 269475e7992aSrie */ 2695cce0e03bSab if (aplist_append(&alist, lmp, AL_CNT_LAZYFIND) == NULL) 269667d74cc3SToomas Soome return (0); 26977c478bd9Sstevel@tonic-gate 26982017c965SRod Evans for (APLIST_TRAVERSE(alist, idx1, lmp1)) { 2699f441771bSRod Evans uint_t dynndx; 270075e7992aSrie Dyninfo *dip, *pdip; 27017c478bd9Sstevel@tonic-gate 270275e7992aSrie /* 270375e7992aSrie * Loop through the lazy DT_NEEDED entries examining each object 270475e7992aSrie * for the required symbol. If the symbol is not found, the 270575e7992aSrie * object is in turn added to the local alist, so that the 270675e7992aSrie * objects lazy DT_NEEDED entries can be examined. 27077c478bd9Sstevel@tonic-gate */ 2708cce0e03bSab lmp = lmp1; 2709f441771bSRod Evans for (dynndx = 0, dip = DYNINFO(lmp), pdip = NULL; 2710f441771bSRod Evans !(dip->di_flags & FLG_DI_IGNORE); dynndx++, pdip = dip++) { 27112017c965SRod Evans Grp_hdl *ghp; 27122017c965SRod Evans Grp_desc *gdp; 27132017c965SRod Evans Rt_map *nlmp, *llmp; 27142017c965SRod Evans Slookup sl2; 271508278a5eSRod Evans Sresult sr; 27162017c965SRod Evans Aliste idx2; 27177c478bd9Sstevel@tonic-gate 271875e7992aSrie if (((dip->di_flags & FLG_DI_LAZY) == 0) || 27197c478bd9Sstevel@tonic-gate dip->di_info) 27207c478bd9Sstevel@tonic-gate continue; 27217c478bd9Sstevel@tonic-gate 27227c478bd9Sstevel@tonic-gate /* 272375e7992aSrie * If this object has already failed to lazy load, and 272475e7992aSrie * we're still processing the same runtime linker 272575e7992aSrie * operation that produced the failure, don't bother 272675e7992aSrie * to try and load the object again. 272775e7992aSrie */ 272875e7992aSrie if ((dip->di_flags & FLG_DI_LAZYFAIL) && pdip && 272975e7992aSrie (pdip->di_flags & FLG_DI_POSFLAG1)) { 273075e7992aSrie if (pdip->di_info == (void *)ld_entry_cnt) 273175e7992aSrie continue; 273275e7992aSrie 273375e7992aSrie dip->di_flags &= ~FLG_DI_LAZYFAIL; 273475e7992aSrie pdip->di_info = NULL; 273575e7992aSrie } 273675e7992aSrie 27372017c965SRod Evans /* 27382017c965SRod Evans * Determine the last link-map presently on the callers 27392017c965SRod Evans * link-map control list. 27402017c965SRod Evans */ 27412017c965SRod Evans llmp = lmc->lc_tail; 27422017c965SRod Evans 274375e7992aSrie /* 274475e7992aSrie * Try loading this lazy dependency. If the object 274575e7992aSrie * can't be loaded, consider this non-fatal and continue 274675e7992aSrie * the search. Lazy loaded dependencies need not exist 274775e7992aSrie * and their loading should only turn out to be fatal 274875e7992aSrie * if they are required to satisfy a relocation. 27497c478bd9Sstevel@tonic-gate * 27502017c965SRod Evans * A successful lazy load can mean one of two things: 27512017c965SRod Evans * 27522017c965SRod Evans * - new objects have been loaded, in which case the 275367d74cc3SToomas Soome * objects will have been analyzed, relocated, and 275467d74cc3SToomas Soome * finally moved to the callers control list. 27552017c965SRod Evans * - the objects are already loaded, and this lazy 27562017c965SRod Evans * load has simply associated the referenced object 27572017c965SRod Evans * with it's lazy dependencies. 27582017c965SRod Evans * 27592017c965SRod Evans * If new objects are loaded, look in these objects 27602017c965SRod Evans * first. Note, a new object can be the object being 27612017c965SRod Evans * referenced by this lazy load, however we can also 27622017c965SRod Evans * descend into multiple lazy loads as we relocate this 27632017c965SRod Evans * reference. 27642017c965SRod Evans * 27652017c965SRod Evans * If the symbol hasn't been found, use the referenced 27662017c965SRod Evans * objects handle, as it might have dependencies on 2767e0e63816SRod Evans * objects that are already loaded. Note that existing 2768e0e63816SRod Evans * objects might have already been searched and skipped 2769e0e63816SRod Evans * as non-available to this caller. However, a lazy 2770e0e63816SRod Evans * load might have caused the promotion of modes, or 2771e0e63816SRod Evans * added this object to the family of the caller. In 2772e0e63816SRod Evans * either case, the handle associated with the object 2773e0e63816SRod Evans * is then used to carry out the symbol search. 27747c478bd9Sstevel@tonic-gate */ 2775f441771bSRod Evans if ((nlmp = elf_lazy_load(lmp, &sl1, dynndx, name, 27762017c965SRod Evans FLG_RT_PRIHDL, &ghp, in_nfavl)) == NULL) 27777c478bd9Sstevel@tonic-gate continue; 27787c478bd9Sstevel@tonic-gate 27792017c965SRod Evans if (NEXT_RT_MAP(llmp)) { 27802017c965SRod Evans /* 27812017c965SRod Evans * Look in any new objects. 27822017c965SRod Evans */ 27832017c965SRod Evans sl1.sl_imap = NEXT_RT_MAP(llmp); 27842017c965SRod Evans sl1.sl_flags &= ~LKUP_STDRELOC; 27852017c965SRod Evans 278608278a5eSRod Evans /* 278708278a5eSRod Evans * Initialize a local symbol result descriptor, 278808278a5eSRod Evans * using the original symbol name. 278908278a5eSRod Evans */ 279008278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name); 279108278a5eSRod Evans 279208278a5eSRod Evans if (lookup_sym(&sl1, &sr, binfo, in_nfavl)) { 279308278a5eSRod Evans *srp = sr; 279408278a5eSRod Evans return (1); 279508278a5eSRod Evans } 27962017c965SRod Evans } 27972017c965SRod Evans 27987c478bd9Sstevel@tonic-gate /* 2799e0e63816SRod Evans * Use the objects handle to inspect the family of 2800e0e63816SRod Evans * objects associated with the handle. Note, there's 28012017c965SRod Evans * a possibility of overlap with the above search, 28022017c965SRod Evans * should a lazy load bring in new objects and 28032017c965SRod Evans * reference existing objects. 28047c478bd9Sstevel@tonic-gate */ 28052017c965SRod Evans sl2 = sl1; 28062017c965SRod Evans for (ALIST_TRAVERSE(ghp->gh_depends, idx2, gdp)) { 2807e0e63816SRod Evans if ((gdp->gd_depend != NEXT_RT_MAP(llmp)) && 28082017c965SRod Evans (gdp->gd_flags & GPD_DLSYM)) { 28092017c965SRod Evans 28102017c965SRod Evans sl2.sl_imap = gdp->gd_depend; 28112017c965SRod Evans sl2.sl_flags |= LKUP_FIRST; 28122017c965SRod Evans 281308278a5eSRod Evans /* 281408278a5eSRod Evans * Initialize a local symbol result 281508278a5eSRod Evans * descriptor, using the original 281608278a5eSRod Evans * symbol name. 281708278a5eSRod Evans */ 281808278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name); 281908278a5eSRod Evans 282008278a5eSRod Evans if (lookup_sym(&sl2, &sr, binfo, 282108278a5eSRod Evans in_nfavl)) { 282208278a5eSRod Evans *srp = sr; 282308278a5eSRod Evans return (1); 282408278a5eSRod Evans } 28252017c965SRod Evans } 28262017c965SRod Evans } 28272017c965SRod Evans 28287c478bd9Sstevel@tonic-gate /* 28297c478bd9Sstevel@tonic-gate * Some dlsym() operations are already traversing a 28307c478bd9Sstevel@tonic-gate * link-map (dlopen(0)), and thus there's no need to 28312017c965SRod Evans * save them on the dynamic dependency list. 28327c478bd9Sstevel@tonic-gate */ 28332017c965SRod Evans if (slp->sl_flags & LKUP_NODESCENT) 28342017c965SRod Evans continue; 28352017c965SRod Evans 283667d74cc3SToomas Soome if (aplist_test(&alist, nlmp, AL_CNT_LAZYFIND) == 0) 283708278a5eSRod Evans return (0); 28387c478bd9Sstevel@tonic-gate } 28397c478bd9Sstevel@tonic-gate } 28407c478bd9Sstevel@tonic-gate 284108278a5eSRod Evans return (0); 28427c478bd9Sstevel@tonic-gate } 28437c478bd9Sstevel@tonic-gate 28447c478bd9Sstevel@tonic-gate /* 28457c478bd9Sstevel@tonic-gate * Warning message for bad r_offset. 28467c478bd9Sstevel@tonic-gate */ 28477c478bd9Sstevel@tonic-gate void 28487c478bd9Sstevel@tonic-gate elf_reloc_bad(Rt_map *lmp, void *rel, uchar_t rtype, ulong_t roffset, 28497c478bd9Sstevel@tonic-gate ulong_t rsymndx) 28507c478bd9Sstevel@tonic-gate { 285137ffaf83SRod Evans const char *name = NULL; 28525aefb655Srie Lm_list *lml = LIST(lmp); 28537c478bd9Sstevel@tonic-gate int trace; 28547c478bd9Sstevel@tonic-gate 28555aefb655Srie if ((lml->lm_flags & LML_FLG_TRC_ENABLE) && 28567c478bd9Sstevel@tonic-gate (((rtld_flags & RT_FL_SILENCERR) == 0) || 28575aefb655Srie (lml->lm_flags & LML_FLG_TRC_VERBOSE))) 28587c478bd9Sstevel@tonic-gate trace = 1; 28597c478bd9Sstevel@tonic-gate else 28607c478bd9Sstevel@tonic-gate trace = 0; 28617c478bd9Sstevel@tonic-gate 28625aefb655Srie if ((trace == 0) && (DBG_ENABLED == 0)) 28637c478bd9Sstevel@tonic-gate return; 28647c478bd9Sstevel@tonic-gate 28657c478bd9Sstevel@tonic-gate if (rsymndx) { 28667c478bd9Sstevel@tonic-gate Sym *symref = (Sym *)((ulong_t)SYMTAB(lmp) + 2867a953e2b1Srie (rsymndx * SYMENT(lmp))); 28687c478bd9Sstevel@tonic-gate 28697c478bd9Sstevel@tonic-gate if (ELF_ST_BIND(symref->st_info) != STB_LOCAL) 28707c478bd9Sstevel@tonic-gate name = (char *)(STRTAB(lmp) + symref->st_name); 28717c478bd9Sstevel@tonic-gate } 28727c478bd9Sstevel@tonic-gate 2873481bba9eSRod Evans if (name == NULL) 287456deab07SRod Evans name = MSG_INTL(MSG_STR_UNKNOWN); 28757c478bd9Sstevel@tonic-gate 28767c478bd9Sstevel@tonic-gate if (trace) { 28777c478bd9Sstevel@tonic-gate const char *rstr; 28787c478bd9Sstevel@tonic-gate 28795aefb655Srie rstr = _conv_reloc_type((uint_t)rtype); 28807c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_REL_ERR1), rstr, name, 28817c478bd9Sstevel@tonic-gate EC_ADDR(roffset)); 28827c478bd9Sstevel@tonic-gate return; 28837c478bd9Sstevel@tonic-gate } 28847c478bd9Sstevel@tonic-gate 28855aefb655Srie Dbg_reloc_error(lml, ELF_DBG_RTLD, M_MACH, M_REL_SHT_TYPE, rel, name); 28867c478bd9Sstevel@tonic-gate } 2887d326b23bSrie 2888d326b23bSrie /* 2889d326b23bSrie * Resolve a static TLS relocation. 2890d326b23bSrie */ 2891d326b23bSrie long 2892d326b23bSrie elf_static_tls(Rt_map *lmp, Sym *sym, void *rel, uchar_t rtype, char *name, 2893d326b23bSrie ulong_t roffset, long value) 2894d326b23bSrie { 2895d326b23bSrie Lm_list *lml = LIST(lmp); 2896d326b23bSrie 2897d326b23bSrie /* 2898d326b23bSrie * Relocations against a static TLS block have limited support once 2899d326b23bSrie * process initialization has completed. Any error condition should be 2900d326b23bSrie * discovered by testing for DF_STATIC_TLS as part of loading an object, 2901d326b23bSrie * however individual relocations are tested in case the dynamic flag 2902d326b23bSrie * had not been set when this object was built. 2903d326b23bSrie */ 2904481bba9eSRod Evans if (PTTLS(lmp) == NULL) { 2905d326b23bSrie DBG_CALL(Dbg_reloc_in(lml, ELF_DBG_RTLD, M_MACH, 2906e23c41c9SAli Bahrami M_REL_SHT_TYPE, rel, NULL, 0, name)); 2907d326b23bSrie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_REL_BADTLS), 2908d326b23bSrie _conv_reloc_type((uint_t)rtype), NAME(lmp), 2909d326b23bSrie name ? demangle(name) : MSG_INTL(MSG_STR_UNKNOWN)); 2910d326b23bSrie return (0); 2911d326b23bSrie } 2912d326b23bSrie 2913d326b23bSrie /* 2914d326b23bSrie * If no static TLS has been set aside for this object, determine if 2915d326b23bSrie * any can be obtained. Enforce that any object using static TLS is 2916d326b23bSrie * non-deletable. 2917d326b23bSrie */ 2918d326b23bSrie if (TLSSTATOFF(lmp) == 0) { 2919d326b23bSrie FLAGS1(lmp) |= FL1_RT_TLSSTAT; 2920d326b23bSrie MODE(lmp) |= RTLD_NODELETE; 2921d326b23bSrie 2922d326b23bSrie if (tls_assign(lml, lmp, PTTLS(lmp)) == 0) { 2923d326b23bSrie DBG_CALL(Dbg_reloc_in(lml, ELF_DBG_RTLD, M_MACH, 2924e23c41c9SAli Bahrami M_REL_SHT_TYPE, rel, NULL, 0, name)); 2925d326b23bSrie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_REL_BADTLS), 2926d326b23bSrie _conv_reloc_type((uint_t)rtype), NAME(lmp), 2927d326b23bSrie name ? demangle(name) : MSG_INTL(MSG_STR_UNKNOWN)); 2928d326b23bSrie return (0); 2929d326b23bSrie } 2930d326b23bSrie } 2931d326b23bSrie 2932d326b23bSrie /* 2933d326b23bSrie * Typically, a static TLS offset is maintained as a symbols value. 2934d326b23bSrie * For local symbols that are not apart of the dynamic symbol table, 2935d326b23bSrie * the TLS relocation points to a section symbol, and the static TLS 2936d326b23bSrie * offset was deposited in the associated GOT table. Make sure the GOT 2937d326b23bSrie * is cleared, so that the value isn't reused in do_reloc(). 2938d326b23bSrie */ 2939d326b23bSrie if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) { 2940d326b23bSrie if ((ELF_ST_TYPE(sym->st_info) == STT_SECTION)) { 2941d326b23bSrie value = *(long *)roffset; 2942d326b23bSrie *(long *)roffset = 0; 2943d326b23bSrie } else { 2944d326b23bSrie value = sym->st_value; 2945d326b23bSrie } 2946d326b23bSrie } 2947d326b23bSrie return (-(TLSSTATOFF(lmp) - value)); 2948d326b23bSrie } 2949dae2dfb7Srie 2950dae2dfb7Srie /* 2951dae2dfb7Srie * If the symbol is not found and the reference was not to a weak symbol, report 2952dae2dfb7Srie * an error. Weak references may be unresolved. 2953dae2dfb7Srie */ 2954dae2dfb7Srie int 2955dae2dfb7Srie elf_reloc_error(Rt_map *lmp, const char *name, void *rel, uint_t binfo) 2956dae2dfb7Srie { 2957dae2dfb7Srie Lm_list *lml = LIST(lmp); 2958dae2dfb7Srie 2959dae2dfb7Srie /* 2960dae2dfb7Srie * Under crle(1), relocation failures are ignored. 2961dae2dfb7Srie */ 2962dae2dfb7Srie if (lml->lm_flags & LML_FLG_IGNRELERR) 2963dae2dfb7Srie return (1); 2964dae2dfb7Srie 2965dae2dfb7Srie /* 2966dae2dfb7Srie * Under ldd(1), unresolved references are reported. However, if the 2967dae2dfb7Srie * original reference is EXTERN or PARENT these references are ignored 2968dae2dfb7Srie * unless ldd's -p option is in effect. 2969dae2dfb7Srie */ 2970dae2dfb7Srie if (lml->lm_flags & LML_FLG_TRC_WARN) { 2971dae2dfb7Srie if (((binfo & DBG_BINFO_REF_MSK) == 0) || 2972dae2dfb7Srie ((lml->lm_flags & LML_FLG_TRC_NOPAREXT) != 0)) { 2973dae2dfb7Srie (void) printf(MSG_INTL(MSG_LDD_SYM_NFOUND), 2974dae2dfb7Srie demangle(name), NAME(lmp)); 2975dae2dfb7Srie } 2976dae2dfb7Srie return (1); 2977dae2dfb7Srie } 2978dae2dfb7Srie 2979dae2dfb7Srie /* 2980dae2dfb7Srie * Otherwise, the unresolved references is fatal. 2981dae2dfb7Srie */ 2982dae2dfb7Srie DBG_CALL(Dbg_reloc_in(lml, ELF_DBG_RTLD, M_MACH, M_REL_SHT_TYPE, rel, 2983e23c41c9SAli Bahrami NULL, 0, name)); 2984dae2dfb7Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_REL_NOSYM), NAME(lmp), 2985dae2dfb7Srie demangle(name)); 2986dae2dfb7Srie 2987dae2dfb7Srie return (0); 2988dae2dfb7Srie } 2989