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.
3056726c7eSRobert Mustacchi * Copyright 2022 Oxide Computer Company
31b533f56bSRobert Mustacchi */
327257d1b4Sraf
337c478bd9Sstevel@tonic-gate /*
347c478bd9Sstevel@tonic-gate * Object file dependent support for ELF objects.
357c478bd9Sstevel@tonic-gate */
367c478bd9Sstevel@tonic-gate
377c478bd9Sstevel@tonic-gate #include <stdio.h>
387c478bd9Sstevel@tonic-gate #include <sys/procfs.h>
397c478bd9Sstevel@tonic-gate #include <sys/mman.h>
407c478bd9Sstevel@tonic-gate #include <sys/debug.h>
417c478bd9Sstevel@tonic-gate #include <string.h>
427c478bd9Sstevel@tonic-gate #include <limits.h>
437c478bd9Sstevel@tonic-gate #include <dlfcn.h>
445aefb655Srie #include <debug.h>
455aefb655Srie #include <conv.h>
467c478bd9Sstevel@tonic-gate #include "_rtld.h"
477c478bd9Sstevel@tonic-gate #include "_audit.h"
487c478bd9Sstevel@tonic-gate #include "_elf.h"
49f441771bSRod Evans #include "_inline_gen.h"
50f441771bSRod Evans #include "_inline_reloc.h"
517c478bd9Sstevel@tonic-gate #include "msg.h"
527c478bd9Sstevel@tonic-gate
537c478bd9Sstevel@tonic-gate /*
547c478bd9Sstevel@tonic-gate * Default and secure dependency search paths.
557c478bd9Sstevel@tonic-gate */
5656deab07SRod Evans static Spath_defn _elf_def_dirs[] = {
577c478bd9Sstevel@tonic-gate #if defined(_ELF64)
5856deab07SRod Evans { MSG_ORIG(MSG_PTH_LIB_64), MSG_PTH_LIB_64_SIZE },
5956deab07SRod Evans { MSG_ORIG(MSG_PTH_USRLIB_64), MSG_PTH_USRLIB_64_SIZE },
607c478bd9Sstevel@tonic-gate #else
6156deab07SRod Evans { MSG_ORIG(MSG_PTH_LIB), MSG_PTH_LIB_SIZE },
6256deab07SRod Evans { MSG_ORIG(MSG_PTH_USRLIB), MSG_PTH_USRLIB_SIZE },
637c478bd9Sstevel@tonic-gate #endif
6456deab07SRod Evans { 0, 0 }
657c478bd9Sstevel@tonic-gate };
667c478bd9Sstevel@tonic-gate
6756deab07SRod Evans static Spath_defn _elf_sec_dirs[] = {
687c478bd9Sstevel@tonic-gate #if defined(_ELF64)
6956deab07SRod Evans { MSG_ORIG(MSG_PTH_LIBSE_64), MSG_PTH_LIBSE_64_SIZE },
7056deab07SRod Evans { MSG_ORIG(MSG_PTH_USRLIBSE_64), MSG_PTH_USRLIBSE_64_SIZE },
717c478bd9Sstevel@tonic-gate #else
7256deab07SRod Evans { MSG_ORIG(MSG_PTH_LIBSE), MSG_PTH_LIBSE_SIZE },
7356deab07SRod Evans { MSG_ORIG(MSG_PTH_USRLIBSE), MSG_PTH_USRLIBSE_SIZE },
747c478bd9Sstevel@tonic-gate #endif
7556deab07SRod Evans { 0, 0 }
767c478bd9Sstevel@tonic-gate };
777c478bd9Sstevel@tonic-gate
7856deab07SRod Evans Alist *elf_def_dirs = NULL;
7956deab07SRod Evans Alist *elf_sec_dirs = NULL;
8056deab07SRod Evans
817c478bd9Sstevel@tonic-gate /*
827c478bd9Sstevel@tonic-gate * Defines for local functions.
837c478bd9Sstevel@tonic-gate */
847c478bd9Sstevel@tonic-gate static void elf_dladdr(ulong_t, Rt_map *, Dl_info *, void **, int);
8556deab07SRod Evans static Addr elf_entry_point(void);
8656deab07SRod Evans static int elf_fix_name(const char *, Rt_map *, Alist **, Aliste, uint_t);
8756deab07SRod Evans static Alist **elf_get_def_dirs(void);
8856deab07SRod Evans static Alist **elf_get_sec_dirs(void);
8956deab07SRod Evans static char *elf_get_so(const char *, const char *, size_t, size_t);
909aa23310Srie static int elf_needed(Lm_list *, Aliste, Rt_map *, int *);
917c478bd9Sstevel@tonic-gate
927c478bd9Sstevel@tonic-gate /*
937c478bd9Sstevel@tonic-gate * Functions and data accessed through indirect pointers.
947c478bd9Sstevel@tonic-gate */
957c478bd9Sstevel@tonic-gate Fct elf_fct = {
9656deab07SRod Evans elf_verify,
9756deab07SRod Evans elf_new_lmp,
9856deab07SRod Evans elf_entry_point,
997c478bd9Sstevel@tonic-gate elf_needed,
1007c478bd9Sstevel@tonic-gate lookup_sym,
1017c478bd9Sstevel@tonic-gate elf_reloc,
10256deab07SRod Evans elf_get_def_dirs,
10356deab07SRod Evans elf_get_sec_dirs,
1047c478bd9Sstevel@tonic-gate elf_fix_name,
1057c478bd9Sstevel@tonic-gate elf_get_so,
1067c478bd9Sstevel@tonic-gate elf_dladdr,
10756deab07SRod Evans dlsym_handle
1087c478bd9Sstevel@tonic-gate };
1097c478bd9Sstevel@tonic-gate
11056deab07SRod Evans /*
11156deab07SRod Evans * Default and secure dependency search paths.
11256deab07SRod Evans */
11356deab07SRod Evans static Alist **
elf_get_def_dirs()11456deab07SRod Evans elf_get_def_dirs()
11556deab07SRod Evans {
11656deab07SRod Evans if (elf_def_dirs == NULL)
11756deab07SRod Evans set_dirs(&elf_def_dirs, _elf_def_dirs, LA_SER_DEFAULT);
11856deab07SRod Evans return (&elf_def_dirs);
11956deab07SRod Evans }
12056deab07SRod Evans
12156deab07SRod Evans static Alist **
elf_get_sec_dirs()12256deab07SRod Evans elf_get_sec_dirs()
12356deab07SRod Evans {
12456deab07SRod Evans if (elf_sec_dirs == NULL)
12556deab07SRod Evans set_dirs(&elf_sec_dirs, _elf_sec_dirs, LA_SER_SECURE);
12656deab07SRod Evans return (&elf_sec_dirs);
12756deab07SRod Evans }
1287c478bd9Sstevel@tonic-gate
1297c478bd9Sstevel@tonic-gate /*
130fec04708SRichard Lowe * For ELF objects we only need perform path expansion. Latent support for
131fec04708SRichard Lowe * other objects may require further work
1327c478bd9Sstevel@tonic-gate */
13356deab07SRod Evans static int
elf_fix_name(const char * name,Rt_map * clmp,Alist ** alpp,Aliste alni,uint_t orig)13456deab07SRod Evans elf_fix_name(const char *name, Rt_map *clmp, Alist **alpp, Aliste alni,
13556deab07SRod Evans uint_t orig)
1367c478bd9Sstevel@tonic-gate {
13756deab07SRod Evans return (expand_paths(clmp, name, alpp, alni, orig, 0));
13856deab07SRod Evans }
13956deab07SRod Evans
14056deab07SRod Evans /*
14108278a5eSRod Evans * Determine whether this object requires capabilities.
14256deab07SRod Evans */
14308278a5eSRod Evans inline static int
elf_cap_check(Fdesc * fdp,Ehdr * ehdr,Rej_desc * rej)14456deab07SRod Evans elf_cap_check(Fdesc *fdp, Ehdr *ehdr, Rej_desc *rej)
14556deab07SRod Evans {
14656deab07SRod Evans Phdr *phdr;
14708278a5eSRod Evans Cap *cap = NULL;
14808278a5eSRod Evans Dyn *dyn = NULL;
14908278a5eSRod Evans char *str = NULL;
15008278a5eSRod Evans Addr base;
151f441771bSRod Evans uint_t cnt, dyncnt;
15256deab07SRod Evans
15308278a5eSRod Evans /*
15408278a5eSRod Evans * If this is a shared object, the base address of the shared object is
15508278a5eSRod Evans * added to all address values defined within the object. Otherwise, if
15608278a5eSRod Evans * this is an executable, all object addresses are used as is.
15708278a5eSRod Evans */
15808278a5eSRod Evans if (ehdr->e_type == ET_EXEC)
15908278a5eSRod Evans base = 0;
16008278a5eSRod Evans else
16108278a5eSRod Evans base = (Addr)ehdr;
16208278a5eSRod Evans
16356deab07SRod Evans /* LINTED */
16456deab07SRod Evans phdr = (Phdr *)((char *)ehdr + ehdr->e_phoff);
16556deab07SRod Evans for (cnt = 0; cnt < ehdr->e_phnum; cnt++, phdr++) {
16608278a5eSRod Evans if (phdr->p_type == PT_DYNAMIC) {
16708278a5eSRod Evans /* LINTED */
16808278a5eSRod Evans dyn = (Dyn *)((uintptr_t)phdr->p_vaddr + base);
169f441771bSRod Evans dyncnt = phdr->p_filesz / sizeof (Dyn);
17008278a5eSRod Evans } else if (phdr->p_type == PT_SUNWCAP) {
17108278a5eSRod Evans /* LINTED */
17208278a5eSRod Evans cap = (Cap *)((uintptr_t)phdr->p_vaddr + base);
17308278a5eSRod Evans }
17408278a5eSRod Evans }
17556deab07SRod Evans
17608278a5eSRod Evans if (cap) {
17708278a5eSRod Evans /*
17808278a5eSRod Evans * From the .dynamic section, determine the associated string
17908278a5eSRod Evans * table. Required for CA_SUNW_MACH and CA_SUNW_PLAT
18008278a5eSRod Evans * processing.
18108278a5eSRod Evans */
182f441771bSRod Evans while (dyn && dyncnt) {
18308278a5eSRod Evans if (dyn->d_tag == DT_NULL) {
18408278a5eSRod Evans break;
18508278a5eSRod Evans } else if (dyn->d_tag == DT_STRTAB) {
18608278a5eSRod Evans str = (char *)(dyn->d_un.d_ptr + base);
18708278a5eSRod Evans break;
18856deab07SRod Evans }
189f441771bSRod Evans dyn++, dyncnt--;
19056deab07SRod Evans }
19156deab07SRod Evans }
19208278a5eSRod Evans
19308278a5eSRod Evans /*
19408278a5eSRod Evans * Establish any alternative capabilities, and validate this object
19508278a5eSRod Evans * if it defines it's own capabilities information.
19608278a5eSRod Evans */
19708278a5eSRod Evans return (cap_check_fdesc(fdp, cap, str, rej));
1987c478bd9Sstevel@tonic-gate }
1997c478bd9Sstevel@tonic-gate
2007c478bd9Sstevel@tonic-gate /*
2017c478bd9Sstevel@tonic-gate * Determine if we have been given an ELF file and if so determine if the file
2027c478bd9Sstevel@tonic-gate * is compatible. Returns 1 if true, else 0 and sets the reject descriptor
2037c478bd9Sstevel@tonic-gate * with associated error information.
2047c478bd9Sstevel@tonic-gate */
20556deab07SRod Evans Fct *
elf_verify(caddr_t addr,size_t size,Fdesc * fdp,const char * name,Rej_desc * rej)20656deab07SRod Evans elf_verify(caddr_t addr, size_t size, Fdesc *fdp, const char *name,
20756deab07SRod Evans Rej_desc *rej)
2087c478bd9Sstevel@tonic-gate {
2097c478bd9Sstevel@tonic-gate Ehdr *ehdr;
21056deab07SRod Evans char *caddr = (char *)addr;
2117c478bd9Sstevel@tonic-gate
2127c478bd9Sstevel@tonic-gate /*
2137c478bd9Sstevel@tonic-gate * Determine if we're an elf file. If not simply return, we don't set
2147c478bd9Sstevel@tonic-gate * any rejection information as this test allows use to scroll through
215fec04708SRichard Lowe * the objects we support (ELF).
2167c478bd9Sstevel@tonic-gate */
21756deab07SRod Evans if (size < sizeof (Ehdr) ||
21856deab07SRod Evans caddr[EI_MAG0] != ELFMAG0 ||
21956deab07SRod Evans caddr[EI_MAG1] != ELFMAG1 ||
22056deab07SRod Evans caddr[EI_MAG2] != ELFMAG2 ||
22156deab07SRod Evans caddr[EI_MAG3] != ELFMAG3) {
22256deab07SRod Evans return (NULL);
2237c478bd9Sstevel@tonic-gate }
2247c478bd9Sstevel@tonic-gate
2257c478bd9Sstevel@tonic-gate /*
2267c478bd9Sstevel@tonic-gate * Check class and encoding.
2277c478bd9Sstevel@tonic-gate */
2287c478bd9Sstevel@tonic-gate /* LINTED */
22956deab07SRod Evans ehdr = (Ehdr *)addr;
2307c478bd9Sstevel@tonic-gate if (ehdr->e_ident[EI_CLASS] != M_CLASS) {
2317c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_CLASS;
2327c478bd9Sstevel@tonic-gate rej->rej_info = (uint_t)ehdr->e_ident[EI_CLASS];
23356deab07SRod Evans return (NULL);
2347c478bd9Sstevel@tonic-gate }
2357c478bd9Sstevel@tonic-gate if (ehdr->e_ident[EI_DATA] != M_DATA) {
2367c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_DATA;
2377c478bd9Sstevel@tonic-gate rej->rej_info = (uint_t)ehdr->e_ident[EI_DATA];
23856deab07SRod Evans return (NULL);
2397c478bd9Sstevel@tonic-gate }
2407c478bd9Sstevel@tonic-gate if ((ehdr->e_type != ET_REL) && (ehdr->e_type != ET_EXEC) &&
2417c478bd9Sstevel@tonic-gate (ehdr->e_type != ET_DYN)) {
2427c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_TYPE;
2437c478bd9Sstevel@tonic-gate rej->rej_info = (uint_t)ehdr->e_type;
24456deab07SRod Evans return (NULL);
2457c478bd9Sstevel@tonic-gate }
2467c478bd9Sstevel@tonic-gate
2477c478bd9Sstevel@tonic-gate /*
24856deab07SRod Evans * Verify ELF version.
2497c478bd9Sstevel@tonic-gate */
2507c478bd9Sstevel@tonic-gate if (ehdr->e_version > EV_CURRENT) {
2517c478bd9Sstevel@tonic-gate rej->rej_type = SGS_REJ_VERSION;
2527c478bd9Sstevel@tonic-gate rej->rej_info = (uint_t)ehdr->e_version;
25356deab07SRod Evans return (NULL);
2547c478bd9Sstevel@tonic-gate }
25556deab07SRod Evans
25656deab07SRod Evans /*
25756deab07SRod Evans * Verify machine specific flags.
25856deab07SRod Evans */
25956deab07SRod Evans if (elf_mach_flags_check(rej, ehdr) == 0)
26056deab07SRod Evans return (NULL);
26156deab07SRod Evans
26256deab07SRod Evans /*
26308278a5eSRod Evans * Verify any capability requirements. Note, if this object is a shared
26408278a5eSRod Evans * object that is explicitly defined on the ldd(1) command line, and it
26508278a5eSRod Evans * contains an incompatible capabilities requirement, then inform the
26608278a5eSRod Evans * user, but continue processing.
26756deab07SRod Evans */
26856deab07SRod Evans if (elf_cap_check(fdp, ehdr, rej) == 0) {
26956deab07SRod Evans Rt_map *lmp = lml_main.lm_head;
27056deab07SRod Evans
271dde769a2SRod Evans if ((lml_main.lm_flags & LML_FLG_TRC_LDDSTUB) && lmp &&
272dde769a2SRod Evans (FLAGS1(lmp) & FL1_RT_LDDSTUB) && (NEXT(lmp) == NULL)) {
27308278a5eSRod Evans /* LINTED */
27408278a5eSRod Evans (void) printf(MSG_INTL(ldd_warn[rej->rej_type]), name,
27508278a5eSRod Evans rej->rej_str);
27656deab07SRod Evans return (&elf_fct);
27756deab07SRod Evans }
27856deab07SRod Evans return (NULL);
27956deab07SRod Evans }
28056deab07SRod Evans return (&elf_fct);
2817c478bd9Sstevel@tonic-gate }
2827c478bd9Sstevel@tonic-gate
2837c478bd9Sstevel@tonic-gate /*
2847c478bd9Sstevel@tonic-gate * The runtime linker employs lazy loading to provide the libraries needed for
2857c478bd9Sstevel@tonic-gate * debugging, preloading .o's and dldump(). As these are seldom used, the
2867c478bd9Sstevel@tonic-gate * standard startup of ld.so.1 doesn't initialize all the information necessary
2877c478bd9Sstevel@tonic-gate * to perform plt relocation on ld.so.1's link-map. The first time lazy loading
2887c478bd9Sstevel@tonic-gate * is called we get here to perform these initializations:
2897c478bd9Sstevel@tonic-gate *
290f441771bSRod Evans * - elf_needed() is called to establish any ld.so.1 dependencies. These
291f441771bSRod Evans * dependencies should all be lazy loaded, so this routine is typically a
29267d74cc3SToomas Soome * no-op. However, we call elf_needed() for completeness, in case any
293f441771bSRod Evans * NEEDED initialization is required.
2947c478bd9Sstevel@tonic-gate *
2952017c965SRod Evans * - For intel, ld.so.1's JMPSLOT relocations need relative updates. These
2967c478bd9Sstevel@tonic-gate * are by default skipped thus delaying all relative relocation processing
29767d74cc3SToomas Soome * on every invocation of ld.so.1.
2987c478bd9Sstevel@tonic-gate */
2997c478bd9Sstevel@tonic-gate int
elf_rtld_load()3007c478bd9Sstevel@tonic-gate elf_rtld_load()
3017c478bd9Sstevel@tonic-gate {
3027c478bd9Sstevel@tonic-gate Lm_list *lml = &lml_rtld;
3037c478bd9Sstevel@tonic-gate Rt_map *lmp = lml->lm_head;
3047c478bd9Sstevel@tonic-gate
3057c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_PLTREL)
3067c478bd9Sstevel@tonic-gate return (1);
3077c478bd9Sstevel@tonic-gate
3089aa23310Srie if (elf_needed(lml, ALIST_OFF_DATA, lmp, NULL) == 0)
3097c478bd9Sstevel@tonic-gate return (0);
3107c478bd9Sstevel@tonic-gate
31102ca3e02Srie #if defined(__i386)
3127c478bd9Sstevel@tonic-gate /*
3137c478bd9Sstevel@tonic-gate * This is a kludge to give ld.so.1 a performance benefit on i386.
3147c478bd9Sstevel@tonic-gate * It's based around two factors.
3157c478bd9Sstevel@tonic-gate *
3162017c965SRod Evans * - JMPSLOT relocations (PLT's) actually need a relative relocation
3177c478bd9Sstevel@tonic-gate * applied to the GOT entry so that they can find PLT0.
3187c478bd9Sstevel@tonic-gate *
3192017c965SRod Evans * - ld.so.1 does not exercise *any* PLT's before it has made a call
3207c478bd9Sstevel@tonic-gate * to elf_lazy_load(). This is because all dynamic dependencies
32167d74cc3SToomas Soome * are recorded as lazy dependencies.
3227c478bd9Sstevel@tonic-gate */
32356deab07SRod Evans (void) elf_reloc_relative_count((ulong_t)JMPREL(lmp),
3247c478bd9Sstevel@tonic-gate (ulong_t)(PLTRELSZ(lmp) / RELENT(lmp)), (ulong_t)RELENT(lmp),
325f441771bSRod Evans (ulong_t)ADDR(lmp), lmp, NULL, 0);
3267c478bd9Sstevel@tonic-gate #endif
3277c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_PLTREL;
3287c478bd9Sstevel@tonic-gate return (1);
3297c478bd9Sstevel@tonic-gate }
3307c478bd9Sstevel@tonic-gate
3317c478bd9Sstevel@tonic-gate /*
3327c478bd9Sstevel@tonic-gate * Lazy load an object.
3337c478bd9Sstevel@tonic-gate */
3347c478bd9Sstevel@tonic-gate Rt_map *
elf_lazy_load(Rt_map * clmp,Slookup * slp,uint_t ndx,const char * sym,uint_t flags,Grp_hdl ** hdl,int * in_nfavl)3359aa23310Srie elf_lazy_load(Rt_map *clmp, Slookup *slp, uint_t ndx, const char *sym,
3362017c965SRod Evans uint_t flags, Grp_hdl **hdl, int *in_nfavl)
3377c478bd9Sstevel@tonic-gate {
33856deab07SRod Evans Alist *palp = NULL;
339dde769a2SRod Evans Rt_map *nlmp;
34075e7992aSrie Dyninfo *dip = &DYNINFO(clmp)[ndx], *pdip;
3417c478bd9Sstevel@tonic-gate const char *name;
3427c478bd9Sstevel@tonic-gate Lm_list *lml = LIST(clmp);
3437c478bd9Sstevel@tonic-gate Aliste lmco;
3447c478bd9Sstevel@tonic-gate
3457c478bd9Sstevel@tonic-gate /*
346f441771bSRod Evans * If this dependency should be ignored, or has already been processed,
347f441771bSRod Evans * we're done.
3487c478bd9Sstevel@tonic-gate */
34956deab07SRod Evans if (((nlmp = (Rt_map *)dip->di_info) != NULL) ||
350f441771bSRod Evans (dip->di_flags & (FLG_DI_IGNORE | FLG_DI_LDD_DONE)))
3517c478bd9Sstevel@tonic-gate return (nlmp);
3527c478bd9Sstevel@tonic-gate
3537c478bd9Sstevel@tonic-gate /*
35475e7992aSrie * If we're running under ldd(1), indicate that this dependency has been
35575e7992aSrie * processed (see test above). It doesn't matter whether the object is
35675e7992aSrie * successfully loaded or not, this flag simply ensures that we don't
35775e7992aSrie * repeatedly attempt to load an object that has already failed to load.
35875e7992aSrie * To do so would create multiple failure diagnostics for the same
35975e7992aSrie * object under ldd(1).
36075e7992aSrie */
36175e7992aSrie if (lml->lm_flags & LML_FLG_TRC_ENABLE)
36275e7992aSrie dip->di_flags |= FLG_DI_LDD_DONE;
36375e7992aSrie
36475e7992aSrie /*
36575e7992aSrie * Determine the initial dependency name.
3667c478bd9Sstevel@tonic-gate */
367f441771bSRod Evans name = dip->di_name;
3685aefb655Srie DBG_CALL(Dbg_file_lazyload(clmp, name, sym));
3697c478bd9Sstevel@tonic-gate
37075e7992aSrie /*
37175e7992aSrie * If this object needs to establish its own group, make sure a handle
37275e7992aSrie * is created.
37375e7992aSrie */
3747c478bd9Sstevel@tonic-gate if (dip->di_flags & FLG_DI_GROUP)
3752017c965SRod Evans flags |= (FLG_RT_SETGROUP | FLG_RT_PUBHDL);
3767c478bd9Sstevel@tonic-gate
37775e7992aSrie /*
37875e7992aSrie * Lazy dependencies are identified as DT_NEEDED entries with a
37975e7992aSrie * DF_P1_LAZYLOAD flag in the previous DT_POSFLAG_1 element. The
38075e7992aSrie * dynamic information element that corresponds to the DT_POSFLAG_1
38175e7992aSrie * entry is free, and thus used to store the present entrance
38275e7992aSrie * identifier. This identifier is used to prevent multiple attempts to
38375e7992aSrie * load a failed lazy loadable dependency within the same runtime linker
38475e7992aSrie * operation. However, future attempts to reload this dependency are
38575e7992aSrie * still possible.
38675e7992aSrie */
38775e7992aSrie if (ndx && (pdip = dip - 1) && (pdip->di_flags & FLG_DI_POSFLAG1))
38875e7992aSrie pdip->di_info = (void *)slp->sl_id;
38975e7992aSrie
3907c478bd9Sstevel@tonic-gate /*
3917c478bd9Sstevel@tonic-gate * Expand the requested name if necessary.
3927c478bd9Sstevel@tonic-gate */
39356deab07SRod Evans if (elf_fix_name(name, clmp, &palp, AL_CNT_NEEDED, 0) == 0)
39456deab07SRod Evans return (NULL);
3957c478bd9Sstevel@tonic-gate
3967c478bd9Sstevel@tonic-gate /*
397dde769a2SRod Evans * Establish a link-map control list for this request.
3987c478bd9Sstevel@tonic-gate */
39967d74cc3SToomas Soome if ((lmco = create_cntl(lml, 0)) == 0) {
4002020b2b6SRod Evans remove_alist(&palp, 1);
401dde769a2SRod Evans return (NULL);
402dde769a2SRod Evans }
4037c478bd9Sstevel@tonic-gate
4047c478bd9Sstevel@tonic-gate /*
4057c478bd9Sstevel@tonic-gate * Load the associated object.
4067c478bd9Sstevel@tonic-gate */
4077c478bd9Sstevel@tonic-gate dip->di_info = nlmp =
4082017c965SRod Evans load_one(lml, lmco, palp, clmp, MODE(clmp), flags, hdl, in_nfavl);
4097c478bd9Sstevel@tonic-gate
4107c478bd9Sstevel@tonic-gate /*
4117c478bd9Sstevel@tonic-gate * Remove any expanded pathname infrastructure. Reduce the pending lazy
4127c478bd9Sstevel@tonic-gate * dependency count of the caller, together with the link-map lists
4137c478bd9Sstevel@tonic-gate * count of objects that still have lazy dependencies pending.
4147c478bd9Sstevel@tonic-gate */
4152020b2b6SRod Evans remove_alist(&palp, 1);
4167c478bd9Sstevel@tonic-gate if (--LAZY(clmp) == 0)
4177c478bd9Sstevel@tonic-gate LIST(clmp)->lm_lazy--;
4187c478bd9Sstevel@tonic-gate
4197c478bd9Sstevel@tonic-gate /*
42002ca3e02Srie * Finish processing the objects associated with this request, and
42102ca3e02Srie * create an association between the caller and this dependency.
4227c478bd9Sstevel@tonic-gate */
42375e7992aSrie if (nlmp && ((bind_one(clmp, nlmp, BND_NEEDED) == 0) ||
4242020b2b6SRod Evans ((nlmp = analyze_lmc(lml, lmco, nlmp, clmp, in_nfavl)) == NULL) ||
4259aa23310Srie (relocate_lmc(lml, lmco, clmp, nlmp, in_nfavl) == 0)))
42656deab07SRod Evans dip->di_info = nlmp = NULL;
4277c478bd9Sstevel@tonic-gate
4287c478bd9Sstevel@tonic-gate /*
42902ca3e02Srie * If this lazyload has failed, and we've created a new link-map
43002ca3e02Srie * control list to which this request has added objects, then remove
43102ca3e02Srie * all the objects that have been associated to this request.
4327c478bd9Sstevel@tonic-gate */
433481bba9eSRod Evans if ((nlmp == NULL) && (lmco != ALIST_OFF_DATA))
434481bba9eSRod Evans remove_lmc(lml, clmp, lmco, name);
4357c478bd9Sstevel@tonic-gate
4367c478bd9Sstevel@tonic-gate /*
437dde769a2SRod Evans * Remove any temporary link-map control list.
4387c478bd9Sstevel@tonic-gate */
439481bba9eSRod Evans if (lmco != ALIST_OFF_DATA)
4407c478bd9Sstevel@tonic-gate remove_cntl(lml, lmco);
4417c478bd9Sstevel@tonic-gate
44275e7992aSrie /*
44375e7992aSrie * If this lazy loading failed, record the fact, and bump the lazy
44475e7992aSrie * counts.
44575e7992aSrie */
44656deab07SRod Evans if (nlmp == NULL) {
44775e7992aSrie dip->di_flags |= FLG_DI_LAZYFAIL;
44875e7992aSrie if (LAZY(clmp)++ == 0)
44975e7992aSrie LIST(clmp)->lm_lazy++;
45075e7992aSrie }
45175e7992aSrie
4527c478bd9Sstevel@tonic-gate return (nlmp);
4537c478bd9Sstevel@tonic-gate }
4547c478bd9Sstevel@tonic-gate
4557c478bd9Sstevel@tonic-gate /*
4567c478bd9Sstevel@tonic-gate * Return the entry point of the ELF executable.
4577c478bd9Sstevel@tonic-gate */
45856deab07SRod Evans static Addr
elf_entry_point(void)45956deab07SRod Evans elf_entry_point(void)
4607c478bd9Sstevel@tonic-gate {
46156deab07SRod Evans Rt_map *lmp = lml_main.lm_head;
46256deab07SRod Evans Ehdr *ehdr = (Ehdr *)ADDR(lmp);
46356deab07SRod Evans Addr addr = (Addr)(ehdr->e_entry);
4647c478bd9Sstevel@tonic-gate
46556deab07SRod Evans if ((FLAGS(lmp) & FLG_RT_FIXED) == 0)
46656deab07SRod Evans addr += ADDR(lmp);
4677c478bd9Sstevel@tonic-gate
46856deab07SRod Evans return (addr);
4697c478bd9Sstevel@tonic-gate }
4707c478bd9Sstevel@tonic-gate
4717c478bd9Sstevel@tonic-gate /*
4727c478bd9Sstevel@tonic-gate * Determine if a dependency requires a particular version and if so verify
4737c478bd9Sstevel@tonic-gate * that the version exists in the dependency.
4747c478bd9Sstevel@tonic-gate */
47556deab07SRod Evans int
elf_verify_vers(const char * name,Rt_map * clmp,Rt_map * nlmp)4767c478bd9Sstevel@tonic-gate elf_verify_vers(const char *name, Rt_map *clmp, Rt_map *nlmp)
4777c478bd9Sstevel@tonic-gate {
4787c478bd9Sstevel@tonic-gate Verneed *vnd = VERNEED(clmp);
4797c478bd9Sstevel@tonic-gate int _num, num = VERNEEDNUM(clmp);
4807c478bd9Sstevel@tonic-gate char *cstrs = (char *)STRTAB(clmp);
4817c478bd9Sstevel@tonic-gate Lm_list *lml = LIST(clmp);
4827c478bd9Sstevel@tonic-gate
4837c478bd9Sstevel@tonic-gate /*
4847c478bd9Sstevel@tonic-gate * Traverse the callers version needed information and determine if any
4857c478bd9Sstevel@tonic-gate * specific versions are required from the dependency.
4867c478bd9Sstevel@tonic-gate */
4875aefb655Srie DBG_CALL(Dbg_ver_need_title(LIST(clmp), NAME(clmp)));
4887c478bd9Sstevel@tonic-gate for (_num = 1; _num <= num; _num++,
4897c478bd9Sstevel@tonic-gate vnd = (Verneed *)((Xword)vnd + vnd->vn_next)) {
4907c478bd9Sstevel@tonic-gate Half cnt = vnd->vn_cnt;
4917c478bd9Sstevel@tonic-gate Vernaux *vnap;
4927c478bd9Sstevel@tonic-gate char *nstrs, *need;
4937c478bd9Sstevel@tonic-gate
4947c478bd9Sstevel@tonic-gate /*
4957c478bd9Sstevel@tonic-gate * Determine if a needed entry matches this dependency.
4967c478bd9Sstevel@tonic-gate */
4977c478bd9Sstevel@tonic-gate need = (char *)(cstrs + vnd->vn_file);
4987c478bd9Sstevel@tonic-gate if (strcmp(name, need) != 0)
4997c478bd9Sstevel@tonic-gate continue;
5007c478bd9Sstevel@tonic-gate
5017c478bd9Sstevel@tonic-gate if ((lml->lm_flags & LML_FLG_TRC_VERBOSE) &&
5027c478bd9Sstevel@tonic-gate ((FLAGS1(clmp) & FL1_RT_LDDSTUB) == 0))
5037c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_VER_FIND), name);
5047c478bd9Sstevel@tonic-gate
5057c478bd9Sstevel@tonic-gate /*
5067c478bd9Sstevel@tonic-gate * Validate that each version required actually exists in the
5077c478bd9Sstevel@tonic-gate * dependency.
5087c478bd9Sstevel@tonic-gate */
5097c478bd9Sstevel@tonic-gate nstrs = (char *)STRTAB(nlmp);
5107c478bd9Sstevel@tonic-gate
5117c478bd9Sstevel@tonic-gate for (vnap = (Vernaux *)((Xword)vnd + vnd->vn_aux); cnt;
5127c478bd9Sstevel@tonic-gate cnt--, vnap = (Vernaux *)((Xword)vnap + vnap->vna_next)) {
5137c478bd9Sstevel@tonic-gate char *version, *define;
5147c478bd9Sstevel@tonic-gate Verdef *vdf = VERDEF(nlmp);
5157c478bd9Sstevel@tonic-gate ulong_t _num, num = VERDEFNUM(nlmp);
5167c478bd9Sstevel@tonic-gate int found = 0;
5177c478bd9Sstevel@tonic-gate
518090a8d9eSAli Bahrami /*
519090a8d9eSAli Bahrami * Skip validation of versions that are marked
520090a8d9eSAli Bahrami * INFO. This optimization is used for versions
521090a8d9eSAli Bahrami * that are inherited by another version. Verification
522090a8d9eSAli Bahrami * of the inheriting version is sufficient.
523090a8d9eSAli Bahrami *
524090a8d9eSAli Bahrami * Such versions are recorded in the object for the
525090a8d9eSAli Bahrami * benefit of VERSYM entries that refer to them. This
52608278a5eSRod Evans * provides a purely diagnostic benefit.
527090a8d9eSAli Bahrami */
528090a8d9eSAli Bahrami if (vnap->vna_flags & VER_FLG_INFO)
529090a8d9eSAli Bahrami continue;
530090a8d9eSAli Bahrami
5317c478bd9Sstevel@tonic-gate version = (char *)(cstrs + vnap->vna_name);
5325aefb655Srie DBG_CALL(Dbg_ver_need_entry(lml, 0, need, version));
5337c478bd9Sstevel@tonic-gate
5347c478bd9Sstevel@tonic-gate for (_num = 1; _num <= num; _num++,
5357c478bd9Sstevel@tonic-gate vdf = (Verdef *)((Xword)vdf + vdf->vd_next)) {
5367c478bd9Sstevel@tonic-gate Verdaux *vdap;
5377c478bd9Sstevel@tonic-gate
5387c478bd9Sstevel@tonic-gate if (vnap->vna_hash != vdf->vd_hash)
5397c478bd9Sstevel@tonic-gate continue;
5407c478bd9Sstevel@tonic-gate
5417c478bd9Sstevel@tonic-gate vdap = (Verdaux *)((Xword)vdf + vdf->vd_aux);
5427c478bd9Sstevel@tonic-gate define = (char *)(nstrs + vdap->vda_name);
5437c478bd9Sstevel@tonic-gate if (strcmp(version, define) != 0)
5447c478bd9Sstevel@tonic-gate continue;
5457c478bd9Sstevel@tonic-gate
5467c478bd9Sstevel@tonic-gate found++;
5477c478bd9Sstevel@tonic-gate break;
5487c478bd9Sstevel@tonic-gate }
5497c478bd9Sstevel@tonic-gate
5507c478bd9Sstevel@tonic-gate /*
5517c478bd9Sstevel@tonic-gate * If we're being traced print out any matched version
5527c478bd9Sstevel@tonic-gate * when the verbose (-v) option is in effect. Always
5537c478bd9Sstevel@tonic-gate * print any unmatched versions.
5547c478bd9Sstevel@tonic-gate */
5557c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE) {
556a953e2b1Srie /* BEGIN CSTYLED */
5577c478bd9Sstevel@tonic-gate if (found) {
5587c478bd9Sstevel@tonic-gate if (!(lml->lm_flags & LML_FLG_TRC_VERBOSE))
5597c478bd9Sstevel@tonic-gate continue;
5607c478bd9Sstevel@tonic-gate
5617c478bd9Sstevel@tonic-gate (void) printf(MSG_ORIG(MSG_LDD_VER_FOUND),
5627c478bd9Sstevel@tonic-gate need, version, NAME(nlmp));
5637c478bd9Sstevel@tonic-gate } else {
5647c478bd9Sstevel@tonic-gate if (rtld_flags & RT_FL_SILENCERR)
5657c478bd9Sstevel@tonic-gate continue;
5667c478bd9Sstevel@tonic-gate
5677c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_VER_NFOUND),
5687c478bd9Sstevel@tonic-gate need, version);
5697c478bd9Sstevel@tonic-gate }
570a953e2b1Srie /* END CSTYLED */
5717c478bd9Sstevel@tonic-gate continue;
5727c478bd9Sstevel@tonic-gate }
5737c478bd9Sstevel@tonic-gate
5747c478bd9Sstevel@tonic-gate /*
5757c478bd9Sstevel@tonic-gate * If the version hasn't been found then this is a
5767c478bd9Sstevel@tonic-gate * candidate for a fatal error condition. Weak
5777c478bd9Sstevel@tonic-gate * version definition requirements are silently
5787c478bd9Sstevel@tonic-gate * ignored. Also, if the image inspected for a version
5797c478bd9Sstevel@tonic-gate * definition has no versioning recorded at all then
5807c478bd9Sstevel@tonic-gate * silently ignore this (this provides better backward
5817c478bd9Sstevel@tonic-gate * compatibility to old images created prior to
5827c478bd9Sstevel@tonic-gate * versioning being available). Both of these skipped
5837c478bd9Sstevel@tonic-gate * diagnostics are available under tracing (see above).
5847c478bd9Sstevel@tonic-gate */
5857c478bd9Sstevel@tonic-gate if ((found == 0) && (num != 0) &&
5867c478bd9Sstevel@tonic-gate (!(vnap->vna_flags & VER_FLG_WEAK))) {
5875aefb655Srie eprintf(lml, ERR_FATAL,
5885aefb655Srie MSG_INTL(MSG_VER_NFOUND), need, version,
5895aefb655Srie NAME(clmp));
5907c478bd9Sstevel@tonic-gate return (0);
5917c478bd9Sstevel@tonic-gate }
5927c478bd9Sstevel@tonic-gate }
5937c478bd9Sstevel@tonic-gate }
59420272c2eSAli Bahrami DBG_CALL(Dbg_ver_need_done(lml));
5957c478bd9Sstevel@tonic-gate return (1);
5967c478bd9Sstevel@tonic-gate }
5977c478bd9Sstevel@tonic-gate
5987c478bd9Sstevel@tonic-gate /*
5997c478bd9Sstevel@tonic-gate * Search through the dynamic section for DT_NEEDED entries and perform one
6007c478bd9Sstevel@tonic-gate * of two functions. If only the first argument is specified then load the
6017c478bd9Sstevel@tonic-gate * defined shared object, otherwise add the link map representing the defined
6027c478bd9Sstevel@tonic-gate * link map the the dlopen list.
6037c478bd9Sstevel@tonic-gate */
6047c478bd9Sstevel@tonic-gate static int
elf_needed(Lm_list * lml,Aliste lmco,Rt_map * clmp,int * in_nfavl)6059aa23310Srie elf_needed(Lm_list *lml, Aliste lmco, Rt_map *clmp, int *in_nfavl)
6067c478bd9Sstevel@tonic-gate {
60756deab07SRod Evans Alist *palp = NULL;
608f441771bSRod Evans Dyn *dyn;
609f441771bSRod Evans Dyninfo *dip;
6107c478bd9Sstevel@tonic-gate Word lmflags = lml->lm_flags;
6117c478bd9Sstevel@tonic-gate
6127c478bd9Sstevel@tonic-gate /*
613f441771bSRod Evans * A DYNINFO() structure is created during link-map generation that
614f441771bSRod Evans * parallels the DYN() information, and defines any flags that
615f441771bSRod Evans * influence a dependencies loading.
6167c478bd9Sstevel@tonic-gate */
617f441771bSRod Evans for (dyn = DYN(clmp), dip = DYNINFO(clmp);
618f441771bSRod Evans !(dip->di_flags & FLG_DI_IGNORE); dyn++, dip++) {
619f441771bSRod Evans uint_t flags = 0, silent = 0;
620f441771bSRod Evans const char *name = dip->di_name;
621f441771bSRod Evans Rt_map *nlmp = NULL;
6227c478bd9Sstevel@tonic-gate
623f441771bSRod Evans if ((dip->di_flags & FLG_DI_NEEDED) == 0)
624f441771bSRod Evans continue;
6257c478bd9Sstevel@tonic-gate
626f441771bSRod Evans /*
627f441771bSRod Evans * Skip any deferred dependencies, unless ldd(1) has forced
628f441771bSRod Evans * their processing. By default, deferred dependencies are
629f441771bSRod Evans * only processed when an explicit binding to an individual
630f441771bSRod Evans * deferred reference is made.
631f441771bSRod Evans */
632f441771bSRod Evans if ((dip->di_flags & FLG_DI_DEFERRED) &&
633f441771bSRod Evans ((rtld_flags & RT_FL_DEFERRED) == 0))
6347c478bd9Sstevel@tonic-gate continue;
6357c478bd9Sstevel@tonic-gate
636f441771bSRod Evans /*
637f441771bSRod Evans * NOTE, libc.so.1 can't be lazy loaded. Although a lazy
638f441771bSRod Evans * position flag won't be produced when a RTLDINFO .dynamic
639f441771bSRod Evans * entry is found (introduced with the UPM in Solaris 10), it
640f441771bSRod Evans * was possible to mark libc for lazy loading on previous
641f441771bSRod Evans * releases. To reduce the overhead of testing for this
642f441771bSRod Evans * occurrence, only carry out this check for the first object
643f441771bSRod Evans * on the link-map list (there aren't many applications built
644f441771bSRod Evans * without libc).
645f441771bSRod Evans */
646f441771bSRod Evans if ((dip->di_flags & FLG_DI_LAZY) && (lml->lm_head == clmp) &&
647f441771bSRod Evans (strcmp(name, MSG_ORIG(MSG_FIL_LIBC)) == 0))
648f441771bSRod Evans dip->di_flags &= ~FLG_DI_LAZY;
6497c478bd9Sstevel@tonic-gate
650f441771bSRod Evans /*
651f441771bSRod Evans * Don't bring in lazy loaded objects yet unless we've been
652f441771bSRod Evans * asked to attempt to load all available objects (crle(1) sets
653f441771bSRod Evans * LD_FLAGS=loadavail). Even under RTLD_NOW we don't process
654f441771bSRod Evans * this - RTLD_NOW will cause relocation processing which in
655f441771bSRod Evans * turn might trigger lazy loading, but its possible that the
656f441771bSRod Evans * object has a lazy loaded file with no bindings (i.e., it
657f441771bSRod Evans * should never have been a dependency in the first place).
658f441771bSRod Evans */
659f441771bSRod Evans if (dip->di_flags & FLG_DI_LAZY) {
660f441771bSRod Evans if ((lmflags & LML_FLG_LOADAVAIL) == 0) {
661f441771bSRod Evans LAZY(clmp)++;
662f441771bSRod Evans continue;
663f441771bSRod Evans }
6647c478bd9Sstevel@tonic-gate
6657c478bd9Sstevel@tonic-gate /*
666f441771bSRod Evans * Silence any error messages - see description under
667f441771bSRod Evans * elf_lookup_filtee().
6687c478bd9Sstevel@tonic-gate */
669f441771bSRod Evans if ((rtld_flags & RT_FL_SILENCERR) == 0) {
670f441771bSRod Evans rtld_flags |= RT_FL_SILENCERR;
671f441771bSRod Evans silent = 1;
6727c478bd9Sstevel@tonic-gate }
6737c478bd9Sstevel@tonic-gate }
6747c478bd9Sstevel@tonic-gate
6755aefb655Srie DBG_CALL(Dbg_file_needed(clmp, name));
67675e7992aSrie
67775e7992aSrie /*
67875e7992aSrie * If we're running under ldd(1), indicate that this dependency
67975e7992aSrie * has been processed. It doesn't matter whether the object is
68075e7992aSrie * successfully loaded or not, this flag simply ensures that we
68175e7992aSrie * don't repeatedly attempt to load an object that has already
68275e7992aSrie * failed to load. To do so would create multiple failure
68375e7992aSrie * diagnostics for the same object under ldd(1).
68475e7992aSrie */
6857c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE)
68675e7992aSrie dip->di_flags |= FLG_DI_LDD_DONE;
6877c478bd9Sstevel@tonic-gate
688f441771bSRod Evans /*
689f441771bSRod Evans * Identify any group permission requirements.
690f441771bSRod Evans */
691f441771bSRod Evans if (dip->di_flags & FLG_DI_GROUP)
692f441771bSRod Evans flags = (FLG_RT_SETGROUP | FLG_RT_PUBHDL);
693f441771bSRod Evans
6947c478bd9Sstevel@tonic-gate /*
6957c478bd9Sstevel@tonic-gate * Establish the objects name, load it and establish a binding
6967c478bd9Sstevel@tonic-gate * with the caller.
6977c478bd9Sstevel@tonic-gate */
69856deab07SRod Evans if ((elf_fix_name(name, clmp, &palp, AL_CNT_NEEDED, 0) == 0) ||
69956deab07SRod Evans ((nlmp = load_one(lml, lmco, palp, clmp, MODE(clmp),
70056deab07SRod Evans flags, 0, in_nfavl)) == NULL) ||
70156deab07SRod Evans (bind_one(clmp, nlmp, BND_NEEDED) == 0))
702481bba9eSRod Evans nlmp = NULL;
7037c478bd9Sstevel@tonic-gate
7047c478bd9Sstevel@tonic-gate /*
7057c478bd9Sstevel@tonic-gate * Clean up any infrastructure, including the removal of the
7067c478bd9Sstevel@tonic-gate * error suppression state, if it had been previously set in
7077c478bd9Sstevel@tonic-gate * this routine.
7087c478bd9Sstevel@tonic-gate */
7092020b2b6SRod Evans remove_alist(&palp, 0);
71056deab07SRod Evans
7117c478bd9Sstevel@tonic-gate if (silent)
7127c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_SILENCERR;
71375e7992aSrie
714481bba9eSRod Evans if ((dip->di_info = (void *)nlmp) == NULL) {
7157c478bd9Sstevel@tonic-gate /*
7167c478bd9Sstevel@tonic-gate * If the object could not be mapped, continue if error
7177c478bd9Sstevel@tonic-gate * suppression is established or we're here with ldd(1).
7187c478bd9Sstevel@tonic-gate */
7197c478bd9Sstevel@tonic-gate if ((MODE(clmp) & RTLD_CONFGEN) || (lmflags &
7207c478bd9Sstevel@tonic-gate (LML_FLG_LOADAVAIL | LML_FLG_TRC_ENABLE)))
7217c478bd9Sstevel@tonic-gate continue;
72256deab07SRod Evans else {
7232020b2b6SRod Evans remove_alist(&palp, 1);
7247c478bd9Sstevel@tonic-gate return (0);
72556deab07SRod Evans }
7267c478bd9Sstevel@tonic-gate }
7277c478bd9Sstevel@tonic-gate }
7287c478bd9Sstevel@tonic-gate
7297c478bd9Sstevel@tonic-gate if (LAZY(clmp))
7307c478bd9Sstevel@tonic-gate lml->lm_lazy++;
7317c478bd9Sstevel@tonic-gate
7322020b2b6SRod Evans remove_alist(&palp, 1);
7337c478bd9Sstevel@tonic-gate return (1);
7347c478bd9Sstevel@tonic-gate }
7357c478bd9Sstevel@tonic-gate
7367c478bd9Sstevel@tonic-gate /*
7377c478bd9Sstevel@tonic-gate * A null symbol interpretor. Used if a filter has no associated filtees.
7387c478bd9Sstevel@tonic-gate */
7397c478bd9Sstevel@tonic-gate /* ARGSUSED0 */
74008278a5eSRod Evans static int
elf_null_find_sym(Slookup * slp,Sresult * srp,uint_t * binfo,int * in_nfavl)74108278a5eSRod Evans elf_null_find_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl)
7427c478bd9Sstevel@tonic-gate {
74308278a5eSRod Evans return (0);
7447c478bd9Sstevel@tonic-gate }
7457c478bd9Sstevel@tonic-gate
7467c478bd9Sstevel@tonic-gate /*
7477c478bd9Sstevel@tonic-gate * Disable filtee use.
7487c478bd9Sstevel@tonic-gate */
7497c478bd9Sstevel@tonic-gate static void
elf_disable_filtee(Rt_map * lmp,Dyninfo * dip)7509a411307Srie elf_disable_filtee(Rt_map *lmp, Dyninfo *dip)
7517c478bd9Sstevel@tonic-gate {
7527c478bd9Sstevel@tonic-gate if ((dip->di_flags & FLG_DI_SYMFLTR) == 0) {
7537c478bd9Sstevel@tonic-gate /*
75456deab07SRod Evans * If this is an object filter, null out the reference name.
7557c478bd9Sstevel@tonic-gate */
7567c478bd9Sstevel@tonic-gate if (OBJFLTRNDX(lmp) != FLTR_DISABLED) {
75737ffaf83SRod Evans REFNAME(lmp) = NULL;
7587c478bd9Sstevel@tonic-gate OBJFLTRNDX(lmp) = FLTR_DISABLED;
7597c478bd9Sstevel@tonic-gate
7607c478bd9Sstevel@tonic-gate /*
7617c478bd9Sstevel@tonic-gate * Indicate that this filtee is no longer available.
7627c478bd9Sstevel@tonic-gate */
7637c478bd9Sstevel@tonic-gate if (dip->di_flags & FLG_DI_STDFLTR)
7647c478bd9Sstevel@tonic-gate SYMINTP(lmp) = elf_null_find_sym;
7657c478bd9Sstevel@tonic-gate
7667c478bd9Sstevel@tonic-gate }
7677c478bd9Sstevel@tonic-gate } else if (dip->di_flags & FLG_DI_STDFLTR) {
7687c478bd9Sstevel@tonic-gate /*
7697c478bd9Sstevel@tonic-gate * Indicate that this standard filtee is no longer available.
7707c478bd9Sstevel@tonic-gate */
7717c478bd9Sstevel@tonic-gate if (SYMSFLTRCNT(lmp))
7727c478bd9Sstevel@tonic-gate SYMSFLTRCNT(lmp)--;
7737c478bd9Sstevel@tonic-gate } else {
7747c478bd9Sstevel@tonic-gate /*
7757c478bd9Sstevel@tonic-gate * Indicate that this auxiliary filtee is no longer available.
7767c478bd9Sstevel@tonic-gate */
7777c478bd9Sstevel@tonic-gate if (SYMAFLTRCNT(lmp))
7787c478bd9Sstevel@tonic-gate SYMAFLTRCNT(lmp)--;
7797c478bd9Sstevel@tonic-gate }
7807c478bd9Sstevel@tonic-gate dip->di_flags &= ~MSK_DI_FILTER;
7817c478bd9Sstevel@tonic-gate }
7827c478bd9Sstevel@tonic-gate
7837c478bd9Sstevel@tonic-gate /*
7847c478bd9Sstevel@tonic-gate * Find symbol interpreter - filters.
7857c478bd9Sstevel@tonic-gate * This function is called when the symbols from a shared object should
7867c478bd9Sstevel@tonic-gate * be resolved from the shared objects filtees instead of from within itself.
7877c478bd9Sstevel@tonic-gate *
7887c478bd9Sstevel@tonic-gate * A symbol name of 0 is used to trigger filtee loading.
7897c478bd9Sstevel@tonic-gate */
79008278a5eSRod Evans static int
_elf_lookup_filtee(Slookup * slp,Sresult * srp,uint_t * binfo,uint_t ndx,int * in_nfavl)79108278a5eSRod Evans _elf_lookup_filtee(Slookup *slp, Sresult *srp, uint_t *binfo, uint_t ndx,
7929aa23310Srie int *in_nfavl)
7937c478bd9Sstevel@tonic-gate {
7947c478bd9Sstevel@tonic-gate const char *name = slp->sl_name, *filtees;
7957c478bd9Sstevel@tonic-gate Rt_map *clmp = slp->sl_cmap;
7967c478bd9Sstevel@tonic-gate Rt_map *ilmp = slp->sl_imap;
79756deab07SRod Evans Pdesc *pdp;
7987c478bd9Sstevel@tonic-gate int any;
7997c478bd9Sstevel@tonic-gate Dyninfo *dip = &DYNINFO(ilmp)[ndx];
8007c478bd9Sstevel@tonic-gate Lm_list *lml = LIST(ilmp);
80156deab07SRod Evans Aliste idx;
8027c478bd9Sstevel@tonic-gate
8037c478bd9Sstevel@tonic-gate /*
8047c478bd9Sstevel@tonic-gate * Indicate that the filter has been used. If a binding already exists
8057c478bd9Sstevel@tonic-gate * to the caller, indicate that this object is referenced. This insures
8067c478bd9Sstevel@tonic-gate * we don't generate false unreferenced diagnostics from ldd -u/U or
8077c478bd9Sstevel@tonic-gate * debugging. Don't create a binding regardless, as this filter may
8087c478bd9Sstevel@tonic-gate * have been dlopen()'ed.
8097c478bd9Sstevel@tonic-gate */
8107c478bd9Sstevel@tonic-gate if (name && (ilmp != clmp)) {
8117c478bd9Sstevel@tonic-gate Word tracing = (LIST(clmp)->lm_flags &
8127c478bd9Sstevel@tonic-gate (LML_FLG_TRC_UNREF | LML_FLG_TRC_UNUSED));
8137c478bd9Sstevel@tonic-gate
8145aefb655Srie if (tracing || DBG_ENABLED) {
81567d74cc3SToomas Soome Bnd_desc *bdp;
816cce0e03bSab Aliste idx;
8177c478bd9Sstevel@tonic-gate
8187c478bd9Sstevel@tonic-gate FLAGS1(ilmp) |= FL1_RT_USED;
8197c478bd9Sstevel@tonic-gate
8205aefb655Srie if ((tracing & LML_FLG_TRC_UNREF) || DBG_ENABLED) {
821cce0e03bSab for (APLIST_TRAVERSE(CALLERS(ilmp), idx, bdp)) {
8227c478bd9Sstevel@tonic-gate if (bdp->b_caller == clmp) {
8237c478bd9Sstevel@tonic-gate bdp->b_flags |= BND_REFER;
8247c478bd9Sstevel@tonic-gate break;
8257c478bd9Sstevel@tonic-gate }
8267c478bd9Sstevel@tonic-gate }
8277c478bd9Sstevel@tonic-gate }
8287c478bd9Sstevel@tonic-gate }
8297c478bd9Sstevel@tonic-gate }
8307c478bd9Sstevel@tonic-gate
8317c478bd9Sstevel@tonic-gate /*
8327c478bd9Sstevel@tonic-gate * If this is the first call to process this filter, establish the
8337c478bd9Sstevel@tonic-gate * filtee list. If a configuration file exists, determine if any
8347c478bd9Sstevel@tonic-gate * filtee associations for this filter, and its filtee reference, are
8357c478bd9Sstevel@tonic-gate * defined. Otherwise, process the filtee reference. Any token
8367c478bd9Sstevel@tonic-gate * expansion is also completed at this point (i.e., $PLATFORM).
8377c478bd9Sstevel@tonic-gate */
838f441771bSRod Evans filtees = dip->di_name;
839481bba9eSRod Evans if (dip->di_info == NULL) {
84008278a5eSRod Evans if (rtld_flags2 & RT_FL2_FLTCFG) {
84156deab07SRod Evans elf_config_flt(lml, PATHNAME(ilmp), filtees,
84256deab07SRod Evans (Alist **)&dip->di_info, AL_CNT_FILTEES);
84308278a5eSRod Evans }
844481bba9eSRod Evans if (dip->di_info == NULL) {
8455aefb655Srie DBG_CALL(Dbg_file_filter(lml, NAME(ilmp), filtees, 0));
8467c478bd9Sstevel@tonic-gate if ((lml->lm_flags &
8477c478bd9Sstevel@tonic-gate (LML_FLG_TRC_VERBOSE | LML_FLG_TRC_SEARCH)) &&
8487c478bd9Sstevel@tonic-gate ((FLAGS1(ilmp) & FL1_RT_LDDSTUB) == 0))
8497c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_FIL_FILTER),
8507c478bd9Sstevel@tonic-gate NAME(ilmp), filtees);
8517c478bd9Sstevel@tonic-gate
85256deab07SRod Evans if (expand_paths(ilmp, filtees, (Alist **)&dip->di_info,
85356deab07SRod Evans AL_CNT_FILTEES, 0, 0) == 0) {
8547c478bd9Sstevel@tonic-gate elf_disable_filtee(ilmp, dip);
85508278a5eSRod Evans return (0);
8567c478bd9Sstevel@tonic-gate }
8577c478bd9Sstevel@tonic-gate }
8587c478bd9Sstevel@tonic-gate }
8597c478bd9Sstevel@tonic-gate
8607c478bd9Sstevel@tonic-gate /*
8617c478bd9Sstevel@tonic-gate * Traverse the filtee list, dlopen()'ing any objects specified and
8627c478bd9Sstevel@tonic-gate * using their group handle to lookup the symbol.
8637c478bd9Sstevel@tonic-gate */
86456deab07SRod Evans any = 0;
86556deab07SRod Evans for (ALIST_TRAVERSE((Alist *)dip->di_info, idx, pdp)) {
8667c478bd9Sstevel@tonic-gate int mode;
8677c478bd9Sstevel@tonic-gate Grp_hdl *ghp;
868481bba9eSRod Evans Rt_map *nlmp = NULL;
8697c478bd9Sstevel@tonic-gate
87056deab07SRod Evans if (pdp->pd_plen == 0)
8717c478bd9Sstevel@tonic-gate continue;
8727c478bd9Sstevel@tonic-gate
8737c478bd9Sstevel@tonic-gate /*
8747c478bd9Sstevel@tonic-gate * Establish the mode of the filtee from the filter. As filtees
8757c478bd9Sstevel@tonic-gate * are loaded via a dlopen(), make sure that RTLD_GROUP is set
8767c478bd9Sstevel@tonic-gate * and the filtees aren't global. It would be nice to have
8777c478bd9Sstevel@tonic-gate * RTLD_FIRST used here also, but as filters got out long before
8787c478bd9Sstevel@tonic-gate * RTLD_FIRST was introduced it's a little too late now.
8797c478bd9Sstevel@tonic-gate */
8807c478bd9Sstevel@tonic-gate mode = MODE(ilmp) | RTLD_GROUP;
8817c478bd9Sstevel@tonic-gate mode &= ~RTLD_GLOBAL;
8827c478bd9Sstevel@tonic-gate
8837c478bd9Sstevel@tonic-gate /*
8847c478bd9Sstevel@tonic-gate * Insure that any auxiliary filter can locate symbols from its
8857c478bd9Sstevel@tonic-gate * caller.
8867c478bd9Sstevel@tonic-gate */
8877c478bd9Sstevel@tonic-gate if (dip->di_flags & FLG_DI_AUXFLTR)
8887c478bd9Sstevel@tonic-gate mode |= RTLD_PARENT;
8897c478bd9Sstevel@tonic-gate
8907c478bd9Sstevel@tonic-gate /*
89108278a5eSRod Evans * Process any capability directory. Establish a new link-map
89208278a5eSRod Evans * control list from which to analyze any newly added objects.
8937c478bd9Sstevel@tonic-gate */
89408278a5eSRod Evans if ((pdp->pd_info == NULL) && (pdp->pd_flags & PD_TKN_CAP)) {
89556deab07SRod Evans const char *dir = pdp->pd_pname;
89656deab07SRod Evans Aliste lmco;
89711a2bb38Srie
898dde769a2SRod Evans /*
899dde769a2SRod Evans * Establish a link-map control list for this request.
900dde769a2SRod Evans */
90167d74cc3SToomas Soome if ((lmco = create_cntl(lml, 0)) == 0)
90267d74cc3SToomas Soome return (0);
9037c478bd9Sstevel@tonic-gate
90456deab07SRod Evans /*
90508278a5eSRod Evans * Determine the capability filtees. If none can be
90608278a5eSRod Evans * found, provide suitable diagnostics.
90756deab07SRod Evans */
90808278a5eSRod Evans DBG_CALL(Dbg_cap_filter(lml, dir, ilmp));
90908278a5eSRod Evans if (cap_filtees((Alist **)&dip->di_info, idx, dir,
9102020b2b6SRod Evans lmco, ilmp, clmp, filtees, mode,
91108278a5eSRod Evans (FLG_RT_PUBHDL | FLG_RT_CAP), in_nfavl) == 0) {
91256deab07SRod Evans if ((lml->lm_flags & LML_FLG_TRC_ENABLE) &&
91356deab07SRod Evans (dip->di_flags & FLG_DI_AUXFLTR) &&
91456deab07SRod Evans (rtld_flags & RT_FL_WARNFLTR)) {
91556deab07SRod Evans (void) printf(
91608278a5eSRod Evans MSG_INTL(MSG_LDD_CAP_NFOUND), dir);
91756deab07SRod Evans }
91808278a5eSRod Evans DBG_CALL(Dbg_cap_filter(lml, dir, 0));
91956deab07SRod Evans }
92056deab07SRod Evans
92156deab07SRod Evans /*
92208278a5eSRod Evans * Re-establish the originating path name descriptor,
92308278a5eSRod Evans * as the expansion of capabilities filtees may have
92408278a5eSRod Evans * re-allocated the controlling Alist. Mark this
92556deab07SRod Evans * original pathname descriptor as unused so that the
92656deab07SRod Evans * descriptor isn't revisited for processing. Any real
92708278a5eSRod Evans * capabilities filtees have been added as new pathname
92808278a5eSRod Evans * descriptors following this descriptor.
92956deab07SRod Evans */
93056deab07SRod Evans pdp = alist_item((Alist *)dip->di_info, idx);
93108278a5eSRod Evans pdp->pd_flags &= ~PD_TKN_CAP;
93256deab07SRod Evans pdp->pd_plen = 0;
93311a2bb38Srie
93411a2bb38Srie /*
93508278a5eSRod Evans * Now that any capability objects have been processed,
93608278a5eSRod Evans * remove any temporary link-map control list.
93711a2bb38Srie */
938481bba9eSRod Evans if (lmco != ALIST_OFF_DATA)
93911a2bb38Srie remove_cntl(lml, lmco);
9407c478bd9Sstevel@tonic-gate }
9417c478bd9Sstevel@tonic-gate
94256deab07SRod Evans if (pdp->pd_plen == 0)
9437c478bd9Sstevel@tonic-gate continue;
9447c478bd9Sstevel@tonic-gate
9457c478bd9Sstevel@tonic-gate /*
9467c478bd9Sstevel@tonic-gate * Process an individual filtee.
9477c478bd9Sstevel@tonic-gate */
948481bba9eSRod Evans if (pdp->pd_info == NULL) {
94956deab07SRod Evans const char *filtee = pdp->pd_pname;
9507c478bd9Sstevel@tonic-gate int audit = 0;
9517c478bd9Sstevel@tonic-gate
9525aefb655Srie DBG_CALL(Dbg_file_filtee(lml, NAME(ilmp), filtee, 0));
9537c478bd9Sstevel@tonic-gate
954481bba9eSRod Evans ghp = NULL;
9557c478bd9Sstevel@tonic-gate
9567c478bd9Sstevel@tonic-gate /*
9577c478bd9Sstevel@tonic-gate * Determine if the reference link map is already
9587c478bd9Sstevel@tonic-gate * loaded. As an optimization compare the filtee with
9597c478bd9Sstevel@tonic-gate * our interpretor. The most common filter is
9607c478bd9Sstevel@tonic-gate * libdl.so.1, which is a filter on ld.so.1.
9617c478bd9Sstevel@tonic-gate */
9627c478bd9Sstevel@tonic-gate #if defined(_ELF64)
9637c478bd9Sstevel@tonic-gate if (strcmp(filtee, MSG_ORIG(MSG_PTH_RTLD_64)) == 0) {
9647c478bd9Sstevel@tonic-gate #else
9657c478bd9Sstevel@tonic-gate if (strcmp(filtee, MSG_ORIG(MSG_PTH_RTLD)) == 0) {
9667c478bd9Sstevel@tonic-gate #endif
9672017c965SRod Evans uint_t hflags, rdflags, cdflags;
9682017c965SRod Evans
9692017c965SRod Evans /*
9702017c965SRod Evans * Establish any flags for the handle (Grp_hdl).
9712017c965SRod Evans *
9722017c965SRod Evans * - This is a special, public, ld.so.1
9732017c965SRod Evans * handle.
9742017c965SRod Evans * - Only the first object on this handle
9752017c965SRod Evans * can supply symbols.
9762017c965SRod Evans * - This handle provides a filtee.
9772017c965SRod Evans *
9782017c965SRod Evans * Essentially, this handle allows a caller to
9792017c965SRod Evans * reference the dl*() family of interfaces from
9802017c965SRod Evans * ld.so.1.
9812017c965SRod Evans */
9822017c965SRod Evans hflags = (GPH_PUBLIC | GPH_LDSO |
9832017c965SRod Evans GPH_FIRST | GPH_FILTEE);
9842017c965SRod Evans
9852017c965SRod Evans /*
9862017c965SRod Evans * Establish the flags for the referenced
9872017c965SRod Evans * dependency descriptor (Grp_desc).
9882017c965SRod Evans *
9892017c965SRod Evans * - ld.so.1 is available for dlsym().
9902017c965SRod Evans * - ld.so.1 is available to relocate
9912017c965SRod Evans * against.
9922017c965SRod Evans * - There's no need to add an dependencies
99367d74cc3SToomas Soome * to this handle.
9942017c965SRod Evans */
9952017c965SRod Evans rdflags = (GPD_DLSYM | GPD_RELOC);
9962017c965SRod Evans
9977c478bd9Sstevel@tonic-gate /*
9982017c965SRod Evans * Establish the flags for this callers
9992017c965SRod Evans * dependency descriptor (Grp_desc).
10002017c965SRod Evans *
10012017c965SRod Evans * - The explicit creation of a handle
10022017c965SRod Evans * creates a descriptor for the referenced
10032017c965SRod Evans * object and the parent (caller).
10047c478bd9Sstevel@tonic-gate */
10052017c965SRod Evans cdflags = GPD_PARENT;
10062017c965SRod Evans
10077c478bd9Sstevel@tonic-gate nlmp = lml_rtld.lm_head;
10087c478bd9Sstevel@tonic-gate if ((ghp = hdl_create(&lml_rtld, nlmp, ilmp,
10092017c965SRod Evans hflags, rdflags, cdflags)) == NULL)
1010481bba9eSRod Evans nlmp = NULL;
10117c478bd9Sstevel@tonic-gate
10127c478bd9Sstevel@tonic-gate /*
10137c478bd9Sstevel@tonic-gate * Establish the filter handle to prevent any
10147c478bd9Sstevel@tonic-gate * recursion.
10157c478bd9Sstevel@tonic-gate */
10167c478bd9Sstevel@tonic-gate if (nlmp && ghp)
101756deab07SRod Evans pdp->pd_info = (void *)ghp;
10187c478bd9Sstevel@tonic-gate
10197c478bd9Sstevel@tonic-gate /*
10207c478bd9Sstevel@tonic-gate * Audit the filter/filtee established. Ignore
10217c478bd9Sstevel@tonic-gate * any return from the auditor, as we can't
10227c478bd9Sstevel@tonic-gate * allow ignore filtering to ld.so.1, otherwise
10237c478bd9Sstevel@tonic-gate * nothing is going to work.
10247c478bd9Sstevel@tonic-gate */
102556deab07SRod Evans if (nlmp && ((lml->lm_tflags | AFLAGS(ilmp)) &
102602ca3e02Srie LML_TFLG_AUD_OBJFILTER))
10277c478bd9Sstevel@tonic-gate (void) audit_objfilter(ilmp, filtees,
10287c478bd9Sstevel@tonic-gate nlmp, 0);
10297c478bd9Sstevel@tonic-gate
10307c478bd9Sstevel@tonic-gate } else {
10317c478bd9Sstevel@tonic-gate Rej_desc rej = { 0 };
103256deab07SRod Evans Fdesc fd = { 0 };
103311a2bb38Srie Aliste lmco;
10347c478bd9Sstevel@tonic-gate
103556deab07SRod Evans /*
103656deab07SRod Evans * Trace the inspection of this file, determine
103756deab07SRod Evans * any auditor substitution, and seed the file
103856deab07SRod Evans * descriptor with the originating name.
103956deab07SRod Evans */
104056deab07SRod Evans if (load_trace(lml, pdp, clmp, &fd) == NULL)
104156deab07SRod Evans continue;
104256deab07SRod Evans
10437c478bd9Sstevel@tonic-gate /*
1044dde769a2SRod Evans * Establish a link-map control list for this
1045dde769a2SRod Evans * request.
10467c478bd9Sstevel@tonic-gate */
104767d74cc3SToomas Soome if ((lmco = create_cntl(lml, 0)) == 0)
104867d74cc3SToomas Soome return (0);
10497c478bd9Sstevel@tonic-gate
10507c478bd9Sstevel@tonic-gate /*
105156deab07SRod Evans * Locate and load the filtee.
10527c478bd9Sstevel@tonic-gate */
105356deab07SRod Evans if ((nlmp = load_path(lml, lmco, ilmp, mode,
10542017c965SRod Evans FLG_RT_PUBHDL, &ghp, &fd, &rej,
105556deab07SRod Evans in_nfavl)) == NULL)
10567c478bd9Sstevel@tonic-gate file_notfound(LIST(ilmp), filtee, ilmp,
10572017c965SRod Evans FLG_RT_PUBHDL, &rej);
105856deab07SRod Evans
105956deab07SRod Evans filtee = pdp->pd_pname;
10607c478bd9Sstevel@tonic-gate
10617c478bd9Sstevel@tonic-gate /*
10627c478bd9Sstevel@tonic-gate * Establish the filter handle to prevent any
10637c478bd9Sstevel@tonic-gate * recursion.
10647c478bd9Sstevel@tonic-gate */
10657c478bd9Sstevel@tonic-gate if (nlmp && ghp) {
10667c478bd9Sstevel@tonic-gate ghp->gh_flags |= GPH_FILTEE;
106756deab07SRod Evans pdp->pd_info = (void *)ghp;
10689aa23310Srie
10699aa23310Srie FLAGS1(nlmp) |= FL1_RT_USED;
10707c478bd9Sstevel@tonic-gate }
10717c478bd9Sstevel@tonic-gate
10727c478bd9Sstevel@tonic-gate /*
10737c478bd9Sstevel@tonic-gate * Audit the filter/filtee established. A
10747c478bd9Sstevel@tonic-gate * return of 0 indicates the auditor wishes to
10757c478bd9Sstevel@tonic-gate * ignore this filtee.
10767c478bd9Sstevel@tonic-gate */
10777c478bd9Sstevel@tonic-gate if (nlmp && ((lml->lm_tflags | FLAGS1(ilmp)) &
10787c478bd9Sstevel@tonic-gate LML_TFLG_AUD_OBJFILTER)) {
10797c478bd9Sstevel@tonic-gate if (audit_objfilter(ilmp, filtees,
10807c478bd9Sstevel@tonic-gate nlmp, 0) == 0) {
10817c478bd9Sstevel@tonic-gate audit = 1;
1082481bba9eSRod Evans nlmp = NULL;
10837c478bd9Sstevel@tonic-gate }
10847c478bd9Sstevel@tonic-gate }
10857c478bd9Sstevel@tonic-gate
10867c478bd9Sstevel@tonic-gate /*
10877c478bd9Sstevel@tonic-gate * Finish processing the objects associated with
10887c478bd9Sstevel@tonic-gate * this request. Create an association between
10897c478bd9Sstevel@tonic-gate * this object and the originating filter to
10907c478bd9Sstevel@tonic-gate * provide sufficient information to tear down
10917c478bd9Sstevel@tonic-gate * this filtee if necessary.
10927c478bd9Sstevel@tonic-gate */
109356deab07SRod Evans if (nlmp && ghp && (((nlmp = analyze_lmc(lml,
10942020b2b6SRod Evans lmco, nlmp, clmp, in_nfavl)) == NULL) ||
109556deab07SRod Evans (relocate_lmc(lml, lmco, ilmp, nlmp,
109656deab07SRod Evans in_nfavl) == 0)))
1097481bba9eSRod Evans nlmp = NULL;
10987c478bd9Sstevel@tonic-gate
10997c478bd9Sstevel@tonic-gate /*
11007c478bd9Sstevel@tonic-gate * If the filtee has been successfully
110102ca3e02Srie * processed, then create an association
110202ca3e02Srie * between the filter and filtee. This
110302ca3e02Srie * association provides sufficient information
110402ca3e02Srie * to tear down the filter and filtee if
110502ca3e02Srie * necessary.
11067c478bd9Sstevel@tonic-gate */
11078af2c5b9Srie DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD));
11082017c965SRod Evans if (nlmp && ghp && (hdl_add(ghp, ilmp,
11092017c965SRod Evans GPD_FILTER, NULL) == NULL))
1110481bba9eSRod Evans nlmp = NULL;
111111a2bb38Srie
111256deab07SRod Evans /*
111356deab07SRod Evans * Generate a diagnostic if the filtee couldn't
111456deab07SRod Evans * be loaded.
111556deab07SRod Evans */
1116481bba9eSRod Evans if (nlmp == NULL)
111756deab07SRod Evans DBG_CALL(Dbg_file_filtee(lml, 0, filtee,
111856deab07SRod Evans audit));
111956deab07SRod Evans
112011a2bb38Srie /*
112102ca3e02Srie * If this filtee loading has failed, and we've
112202ca3e02Srie * created a new link-map control list to which
112302ca3e02Srie * this request has added objects, then remove
112402ca3e02Srie * all the objects that have been associated to
112502ca3e02Srie * this request.
112611a2bb38Srie */
1127481bba9eSRod Evans if ((nlmp == NULL) && (lmco != ALIST_OFF_DATA))
1128481bba9eSRod Evans remove_lmc(lml, clmp, lmco, name);
112902ca3e02Srie
113002ca3e02Srie /*
1131dde769a2SRod Evans * Remove any temporary link-map control list.
113202ca3e02Srie */
1133481bba9eSRod Evans if (lmco != ALIST_OFF_DATA)
113411a2bb38Srie remove_cntl(lml, lmco);
11357c478bd9Sstevel@tonic-gate }
11367c478bd9Sstevel@tonic-gate
11377c478bd9Sstevel@tonic-gate /*
113856deab07SRod Evans * If the filtee couldn't be loaded, null out the
113956deab07SRod Evans * path name descriptor entry, and continue the search.
114056deab07SRod Evans * Otherwise, the group handle is retained for future
114156deab07SRod Evans * symbol searches.
11427c478bd9Sstevel@tonic-gate */
1143481bba9eSRod Evans if (nlmp == NULL) {
114456deab07SRod Evans pdp->pd_info = NULL;
114556deab07SRod Evans pdp->pd_plen = 0;
11467c478bd9Sstevel@tonic-gate continue;
11477c478bd9Sstevel@tonic-gate }
11487c478bd9Sstevel@tonic-gate }
11497c478bd9Sstevel@tonic-gate
115056deab07SRod Evans ghp = (Grp_hdl *)pdp->pd_info;
11517c478bd9Sstevel@tonic-gate
11527c478bd9Sstevel@tonic-gate /*
115308278a5eSRod Evans * If name is NULL, we're here to trigger filtee loading.
115408278a5eSRod Evans * Skip the symbol lookup so that we'll continue looking for
115508278a5eSRod Evans * additional filtees.
11567c478bd9Sstevel@tonic-gate */
11577c478bd9Sstevel@tonic-gate if (name) {
11587c478bd9Sstevel@tonic-gate Grp_desc *gdp;
115908278a5eSRod Evans int ret = 0;
1160cce0e03bSab Aliste idx;
11617c478bd9Sstevel@tonic-gate Slookup sl = *slp;
11627c478bd9Sstevel@tonic-gate
116308278a5eSRod Evans sl.sl_flags |= (LKUP_FIRST | LKUP_DLSYM);
11647c478bd9Sstevel@tonic-gate any++;
11657c478bd9Sstevel@tonic-gate
11667c478bd9Sstevel@tonic-gate /*
11677c478bd9Sstevel@tonic-gate * Look for the symbol in the handles dependencies.
11687c478bd9Sstevel@tonic-gate */
1169cce0e03bSab for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) {
1170efb9e8b8Srie if ((gdp->gd_flags & GPD_DLSYM) == 0)
11717c478bd9Sstevel@tonic-gate continue;
11727c478bd9Sstevel@tonic-gate
11737c478bd9Sstevel@tonic-gate /*
11747c478bd9Sstevel@tonic-gate * If our parent is a dependency don't look at
11757c478bd9Sstevel@tonic-gate * it (otherwise we are in a recursive loop).
11767c478bd9Sstevel@tonic-gate * This situation can occur with auxiliary
11777c478bd9Sstevel@tonic-gate * filters if the filtee has a dependency on the
11787c478bd9Sstevel@tonic-gate * filter. This dependency isn't necessary as
11797c478bd9Sstevel@tonic-gate * auxiliary filters are opened RTLD_PARENT, but
11807c478bd9Sstevel@tonic-gate * users may still unknowingly add an explicit
11817c478bd9Sstevel@tonic-gate * dependency to the parent.
11827c478bd9Sstevel@tonic-gate */
11837c478bd9Sstevel@tonic-gate if ((sl.sl_imap = gdp->gd_depend) == ilmp)
11847c478bd9Sstevel@tonic-gate continue;
11857c478bd9Sstevel@tonic-gate
118608278a5eSRod Evans if (((ret = SYMINTP(sl.sl_imap)(&sl, srp, binfo,
118708278a5eSRod Evans in_nfavl)) != 0) ||
11887c478bd9Sstevel@tonic-gate (ghp->gh_flags & GPH_FIRST))
11897c478bd9Sstevel@tonic-gate break;
11907c478bd9Sstevel@tonic-gate }
11917c478bd9Sstevel@tonic-gate
11927c478bd9Sstevel@tonic-gate /*
119302ca3e02Srie * If a symbol has been found, indicate the binding
119402ca3e02Srie * and return the symbol.
11957c478bd9Sstevel@tonic-gate */
119608278a5eSRod Evans if (ret) {
11977c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_FILTEE;
119808278a5eSRod Evans return (1);
11997c478bd9Sstevel@tonic-gate }
12007c478bd9Sstevel@tonic-gate }
12017c478bd9Sstevel@tonic-gate
12027c478bd9Sstevel@tonic-gate /*
12037c478bd9Sstevel@tonic-gate * If this object is tagged to terminate filtee processing we're
12047c478bd9Sstevel@tonic-gate * done.
12057c478bd9Sstevel@tonic-gate */
12065aefb655Srie if (FLAGS1(ghp->gh_ownlmp) & FL1_RT_ENDFILTE)
12077c478bd9Sstevel@tonic-gate break;
12087c478bd9Sstevel@tonic-gate }
12097c478bd9Sstevel@tonic-gate
12107c478bd9Sstevel@tonic-gate /*
12117c478bd9Sstevel@tonic-gate * If we're just here to trigger filtee loading then we're done.
12127c478bd9Sstevel@tonic-gate */
1213481bba9eSRod Evans if (name == NULL)
121408278a5eSRod Evans return (0);
12157c478bd9Sstevel@tonic-gate
12167c478bd9Sstevel@tonic-gate /*
121756deab07SRod Evans * If no filtees have been found for a filter, clean up any path name
121856deab07SRod Evans * descriptors and disable their search completely. For auxiliary
12197c478bd9Sstevel@tonic-gate * filters we can reselect the symbol search function so that we never
12207c478bd9Sstevel@tonic-gate * enter this routine again for this object. For standard filters we
12217c478bd9Sstevel@tonic-gate * use the null symbol routine.
12227c478bd9Sstevel@tonic-gate */
12237c478bd9Sstevel@tonic-gate if (any == 0) {
12242020b2b6SRod Evans remove_alist((Alist **)&(dip->di_info), 1);
12257c478bd9Sstevel@tonic-gate elf_disable_filtee(ilmp, dip);
12267c478bd9Sstevel@tonic-gate }
12277c478bd9Sstevel@tonic-gate
122808278a5eSRod Evans return (0);
12297c478bd9Sstevel@tonic-gate }
12307c478bd9Sstevel@tonic-gate
12317c478bd9Sstevel@tonic-gate /*
12327c478bd9Sstevel@tonic-gate * Focal point for disabling error messages for auxiliary filters. As an
12337c478bd9Sstevel@tonic-gate * auxiliary filter allows for filtee use, but provides a fallback should a
12347c478bd9Sstevel@tonic-gate * filtee not exist (or fail to load), any errors generated as a consequence of
12357c478bd9Sstevel@tonic-gate * trying to load the filtees are typically suppressed. Setting RT_FL_SILENCERR
123608278a5eSRod Evans * suppresses errors generated by eprintf(), but ensures a debug diagnostic is
123708278a5eSRod Evans * produced. ldd(1) employs printf(), and here the selection of whether to
12387c478bd9Sstevel@tonic-gate * print a diagnostic in regards to auxiliary filters is a little more complex.
12397c478bd9Sstevel@tonic-gate *
12402017c965SRod Evans * - The determination of whether to produce an ldd message, or a fatal
12417c478bd9Sstevel@tonic-gate * error message is driven by LML_FLG_TRC_ENABLE.
12422017c965SRod Evans * - More detailed ldd messages may also be driven off of LML_FLG_TRC_WARN,
12437c478bd9Sstevel@tonic-gate * (ldd -d/-r), LML_FLG_TRC_VERBOSE (ldd -v), LML_FLG_TRC_SEARCH (ldd -s),
12447c478bd9Sstevel@tonic-gate * and LML_FLG_TRC_UNREF/LML_FLG_TRC_UNUSED (ldd -U/-u).
12452017c965SRod Evans * - If the calling object is lddstub, then several classes of message are
12467c478bd9Sstevel@tonic-gate * suppressed. The user isn't trying to diagnose lddstub, this is simply
12477c478bd9Sstevel@tonic-gate * a stub executable employed to preload a user specified library against.
12482017c965SRod Evans * - If RT_FL_SILENCERR is in effect then any generic ldd() messages should
12497c478bd9Sstevel@tonic-gate * be suppressed. All detailed ldd messages should still be produced.
12507c478bd9Sstevel@tonic-gate */
125108278a5eSRod Evans int
125208278a5eSRod Evans elf_lookup_filtee(Slookup *slp, Sresult *srp, uint_t *binfo, uint_t ndx,
12539aa23310Srie int *in_nfavl)
12547c478bd9Sstevel@tonic-gate {
12557c478bd9Sstevel@tonic-gate Dyninfo *dip = &DYNINFO(slp->sl_imap)[ndx];
125608278a5eSRod Evans int ret, silent = 0;
12577c478bd9Sstevel@tonic-gate
12587c478bd9Sstevel@tonic-gate /*
12597c478bd9Sstevel@tonic-gate * Make sure this entry is still acting as a filter. We may have tried
12607c478bd9Sstevel@tonic-gate * to process this previously, and disabled it if the filtee couldn't
12617c478bd9Sstevel@tonic-gate * be processed. However, other entries may provide different filtees
12627c478bd9Sstevel@tonic-gate * that are yet to be completed.
12637c478bd9Sstevel@tonic-gate */
12647c478bd9Sstevel@tonic-gate if (dip->di_flags == 0)
126508278a5eSRod Evans return (0);
12667c478bd9Sstevel@tonic-gate
12677c478bd9Sstevel@tonic-gate /*
12687c478bd9Sstevel@tonic-gate * Indicate whether an error message is required should this filtee not
12697c478bd9Sstevel@tonic-gate * be found, based on the type of filter.
12707c478bd9Sstevel@tonic-gate */
12717c478bd9Sstevel@tonic-gate if ((dip->di_flags & FLG_DI_AUXFLTR) &&
12727c478bd9Sstevel@tonic-gate ((rtld_flags & (RT_FL_WARNFLTR | RT_FL_SILENCERR)) == 0)) {
12737c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_SILENCERR;
12747c478bd9Sstevel@tonic-gate silent = 1;
12757c478bd9Sstevel@tonic-gate }
12767c478bd9Sstevel@tonic-gate
127708278a5eSRod Evans ret = _elf_lookup_filtee(slp, srp, binfo, ndx, in_nfavl);
12787c478bd9Sstevel@tonic-gate
12797c478bd9Sstevel@tonic-gate if (silent)
12807c478bd9Sstevel@tonic-gate rtld_flags &= ~RT_FL_SILENCERR;
12817c478bd9Sstevel@tonic-gate
128208278a5eSRod Evans return (ret);
12837c478bd9Sstevel@tonic-gate }
12847c478bd9Sstevel@tonic-gate
12857c478bd9Sstevel@tonic-gate /*
12867c478bd9Sstevel@tonic-gate * Compute the elf hash value (as defined in the ELF access library).
12877c478bd9Sstevel@tonic-gate * The form of the hash table is:
12887c478bd9Sstevel@tonic-gate *
12897c478bd9Sstevel@tonic-gate * |--------------|
12907c478bd9Sstevel@tonic-gate * | # of buckets |
12917c478bd9Sstevel@tonic-gate * |--------------|
12927c478bd9Sstevel@tonic-gate * | # of chains |
12937c478bd9Sstevel@tonic-gate * |--------------|
12947c478bd9Sstevel@tonic-gate * | bucket[] |
12957c478bd9Sstevel@tonic-gate * |--------------|
12967c478bd9Sstevel@tonic-gate * | chain[] |
12977c478bd9Sstevel@tonic-gate * |--------------|
12987c478bd9Sstevel@tonic-gate */
12997c478bd9Sstevel@tonic-gate ulong_t
13007c478bd9Sstevel@tonic-gate elf_hash(const char *name)
13017c478bd9Sstevel@tonic-gate {
13027c478bd9Sstevel@tonic-gate uint_t hval = 0;
13037c478bd9Sstevel@tonic-gate
13047c478bd9Sstevel@tonic-gate while (*name) {
13057c478bd9Sstevel@tonic-gate uint_t g;
13067c478bd9Sstevel@tonic-gate hval = (hval << 4) + *name++;
13077c478bd9Sstevel@tonic-gate if ((g = (hval & 0xf0000000)) != 0)
13087c478bd9Sstevel@tonic-gate hval ^= g >> 24;
13097c478bd9Sstevel@tonic-gate hval &= ~g;
13107c478bd9Sstevel@tonic-gate }
13117c478bd9Sstevel@tonic-gate return ((ulong_t)hval);
13127c478bd9Sstevel@tonic-gate }
13137c478bd9Sstevel@tonic-gate
13147c478bd9Sstevel@tonic-gate /*
131508278a5eSRod Evans * Look up a symbol. The callers lookup information is passed in the Slookup
131608278a5eSRod Evans * structure, and any resultant binding information is returned in the Sresult
131708278a5eSRod Evans * structure.
13187c478bd9Sstevel@tonic-gate */
131908278a5eSRod Evans int
132008278a5eSRod Evans elf_find_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl)
13217c478bd9Sstevel@tonic-gate {
13227c478bd9Sstevel@tonic-gate const char *name = slp->sl_name;
13237c478bd9Sstevel@tonic-gate Rt_map *ilmp = slp->sl_imap;
13247c478bd9Sstevel@tonic-gate ulong_t hash = slp->sl_hash;
132508278a5eSRod Evans uint_t ndx, hashoff, buckets, *chainptr;
13267c478bd9Sstevel@tonic-gate Sym *sym, *symtabptr;
13277c478bd9Sstevel@tonic-gate char *strtabptr, *strtabname;
13287c478bd9Sstevel@tonic-gate uint_t flags1;
13297c478bd9Sstevel@tonic-gate Syminfo *sip;
13307c478bd9Sstevel@tonic-gate
1331660acd81Srie /*
1332660acd81Srie * If we're only here to establish a symbols index, skip the diagnostic
1333660acd81Srie * used to trace a symbol search.
1334660acd81Srie */
13355aefb655Srie if ((slp->sl_flags & LKUP_SYMNDX) == 0)
13365aefb655Srie DBG_CALL(Dbg_syms_lookup(ilmp, name, MSG_ORIG(MSG_STR_ELF)));
13377c478bd9Sstevel@tonic-gate
1338481bba9eSRod Evans if (HASH(ilmp) == NULL)
133908278a5eSRod Evans return (0);
13407c478bd9Sstevel@tonic-gate
13417c478bd9Sstevel@tonic-gate buckets = HASH(ilmp)[0];
13427c478bd9Sstevel@tonic-gate /* LINTED */
134308278a5eSRod Evans hashoff = ((uint_t)hash % buckets) + 2;
13447c478bd9Sstevel@tonic-gate
13457c478bd9Sstevel@tonic-gate /*
134608278a5eSRod Evans * Get the first symbol from the hash chain and initialize the string
13477c478bd9Sstevel@tonic-gate * and symbol table pointers.
13487c478bd9Sstevel@tonic-gate */
134908278a5eSRod Evans if ((ndx = HASH(ilmp)[hashoff]) == 0)
135008278a5eSRod Evans return (0);
13517c478bd9Sstevel@tonic-gate
13527c478bd9Sstevel@tonic-gate chainptr = HASH(ilmp) + 2 + buckets;
13537c478bd9Sstevel@tonic-gate strtabptr = STRTAB(ilmp);
13547c478bd9Sstevel@tonic-gate symtabptr = SYMTAB(ilmp);
13557c478bd9Sstevel@tonic-gate
13567c478bd9Sstevel@tonic-gate while (ndx) {
13577c478bd9Sstevel@tonic-gate sym = symtabptr + ndx;
13587c478bd9Sstevel@tonic-gate strtabname = strtabptr + sym->st_name;
13597c478bd9Sstevel@tonic-gate
13607c478bd9Sstevel@tonic-gate /*
13617c478bd9Sstevel@tonic-gate * Compare the symbol found with the name required. If the
13627c478bd9Sstevel@tonic-gate * names don't match continue with the next hash entry.
13637c478bd9Sstevel@tonic-gate */
13647c478bd9Sstevel@tonic-gate if ((*strtabname++ != *name) || strcmp(strtabname, &name[1])) {
136508278a5eSRod Evans hashoff = ndx + buckets + 2;
13667c478bd9Sstevel@tonic-gate if ((ndx = chainptr[ndx]) != 0)
13677c478bd9Sstevel@tonic-gate continue;
136808278a5eSRod Evans return (0);
13697c478bd9Sstevel@tonic-gate }
13707c478bd9Sstevel@tonic-gate
137108278a5eSRod Evans /*
137208278a5eSRod Evans * Symbols that are defined as hidden within an object usually
137308278a5eSRod Evans * have any references from within the same object bound at
137408278a5eSRod Evans * link-edit time, thus ld.so.1 is not involved. However, if
137508278a5eSRod Evans * these are capabilities symbols, then references to them must
137608278a5eSRod Evans * be resolved at runtime. A hidden symbol can only be bound
137708278a5eSRod Evans * to by the object that defines the symbol.
137808278a5eSRod Evans */
137908278a5eSRod Evans if ((sym->st_shndx != SHN_UNDEF) &&
138008278a5eSRod Evans (ELF_ST_VISIBILITY(sym->st_other) == STV_HIDDEN) &&
138108278a5eSRod Evans (slp->sl_cmap != ilmp))
138208278a5eSRod Evans return (0);
138308278a5eSRod Evans
13843b41b08bSab /*
1385d840867fSab * The Solaris ld does not put DT_VERSYM in the dynamic
1386d840867fSab * section, but the GNU ld does. The GNU runtime linker
1387d840867fSab * interprets the top bit of the 16-bit Versym value
1388d840867fSab * (0x8000) as the "hidden" bit. If this bit is set,
1389d840867fSab * the linker is supposed to act as if that symbol does
1390d840867fSab * not exist. The hidden bit supports their versioning
1391d840867fSab * scheme, which allows multiple incompatible functions
1392d840867fSab * with the same name to exist at different versions
1393d840867fSab * within an object. The Solaris linker does not support this
1394d840867fSab * mechanism, or the model of interface evolution that
1395d840867fSab * it allows, but we honor the hidden bit in GNU ld
1396d840867fSab * produced objects in order to interoperate with them.
13973b41b08bSab */
139808278a5eSRod Evans if (VERSYM(ilmp) && (VERSYM(ilmp)[ndx] & 0x8000)) {
1399d840867fSab DBG_CALL(Dbg_syms_ignore_gnuver(ilmp, name,
14003b41b08bSab ndx, VERSYM(ilmp)[ndx]));
140108278a5eSRod Evans return (0);
14023b41b08bSab }
14033b41b08bSab
1404660acd81Srie /*
140508278a5eSRod Evans * If we're only here to establish a symbol's index, we're done.
1406660acd81Srie */
140708278a5eSRod Evans if (slp->sl_flags & LKUP_SYMNDX) {
140808278a5eSRod Evans srp->sr_dmap = ilmp;
140908278a5eSRod Evans srp->sr_sym = sym;
141008278a5eSRod Evans return (1);
141108278a5eSRod Evans }
1412660acd81Srie
14137c478bd9Sstevel@tonic-gate /*
141408278a5eSRod Evans * If we find a match and the symbol is defined, capture the
14157c478bd9Sstevel@tonic-gate * symbol pointer and the link map in which it was found.
14167c478bd9Sstevel@tonic-gate */
14177c478bd9Sstevel@tonic-gate if (sym->st_shndx != SHN_UNDEF) {
141808278a5eSRod Evans srp->sr_dmap = ilmp;
141908278a5eSRod Evans srp->sr_sym = sym;
14207c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_FOUND;
142108278a5eSRod Evans
14229a411307Srie if ((FLAGS(ilmp) & FLG_RT_OBJINTPO) ||
14239a411307Srie ((FLAGS(ilmp) & FLG_RT_SYMINTPO) &&
14249a411307Srie is_sym_interposer(ilmp, sym)))
14257c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_INTERPOSE;
14267c478bd9Sstevel@tonic-gate break;
14277c478bd9Sstevel@tonic-gate
14287c478bd9Sstevel@tonic-gate /*
14297c478bd9Sstevel@tonic-gate * If we find a match and the symbol is undefined, the
14307c478bd9Sstevel@tonic-gate * symbol type is a function, and the value of the symbol
14317c478bd9Sstevel@tonic-gate * is non zero, then this is a special case. This allows
14327c478bd9Sstevel@tonic-gate * the resolution of a function address to the plt[] entry.
14337c478bd9Sstevel@tonic-gate * See SPARC ABI, Dynamic Linking, Function Addresses for
14347c478bd9Sstevel@tonic-gate * more details.
14357c478bd9Sstevel@tonic-gate */
1436660acd81Srie } else if ((slp->sl_flags & LKUP_SPEC) &&
14377c478bd9Sstevel@tonic-gate (FLAGS(ilmp) & FLG_RT_ISMAIN) && (sym->st_value != 0) &&
14387c478bd9Sstevel@tonic-gate (ELF_ST_TYPE(sym->st_info) == STT_FUNC)) {
143908278a5eSRod Evans srp->sr_dmap = ilmp;
144008278a5eSRod Evans srp->sr_sym = sym;
14417c478bd9Sstevel@tonic-gate *binfo |= (DBG_BINFO_FOUND | DBG_BINFO_PLTADDR);
144208278a5eSRod Evans
14439a411307Srie if ((FLAGS(ilmp) & FLG_RT_OBJINTPO) ||
14449a411307Srie ((FLAGS(ilmp) & FLG_RT_SYMINTPO) &&
14459a411307Srie is_sym_interposer(ilmp, sym)))
14467c478bd9Sstevel@tonic-gate *binfo |= DBG_BINFO_INTERPOSE;
144708278a5eSRod Evans return (1);
14487c478bd9Sstevel@tonic-gate }
14497c478bd9Sstevel@tonic-gate
14507c478bd9Sstevel@tonic-gate /*
14517c478bd9Sstevel@tonic-gate * Undefined symbol.
14527c478bd9Sstevel@tonic-gate */
145308278a5eSRod Evans return (0);
14547c478bd9Sstevel@tonic-gate }
14557c478bd9Sstevel@tonic-gate
14567c478bd9Sstevel@tonic-gate /*
14577c478bd9Sstevel@tonic-gate * We've found a match. Determine if the defining object contains
14587c478bd9Sstevel@tonic-gate * symbol binding information.
14597c478bd9Sstevel@tonic-gate */
1460481bba9eSRod Evans if ((sip = SYMINFO(ilmp)) != NULL)
14619039eeafSab sip += ndx;
14627c478bd9Sstevel@tonic-gate
146360758829Srie /*
146460758829Srie * If this definition is a singleton, and we haven't followed a default
146560758829Srie * symbol search knowing that we're looking for a singleton (presumably
146660758829Srie * because the symbol definition has been changed since the referring
146760758829Srie * object was built), then reject this binding so that the caller can
146860758829Srie * fall back to a standard symbol search.
146960758829Srie */
147060758829Srie if ((ELF_ST_VISIBILITY(sym->st_other) == STV_SINGLETON) &&
147160758829Srie (((slp->sl_flags & LKUP_STANDARD) == 0) ||
147260758829Srie (((slp->sl_flags & LKUP_SINGLETON) == 0) &&
147360758829Srie (LIST(ilmp)->lm_flags & LML_FLG_GROUPSEXIST)))) {
147460758829Srie DBG_CALL(Dbg_bind_reject(slp->sl_cmap, ilmp, name,
147560758829Srie DBG_BNDREJ_SINGLE));
147660758829Srie *binfo |= BINFO_REJSINGLE;
147760758829Srie *binfo &= ~DBG_BINFO_MSK;
147808278a5eSRod Evans return (0);
147960758829Srie }
148060758829Srie
14817c478bd9Sstevel@tonic-gate /*
14827c478bd9Sstevel@tonic-gate * If this is a direct binding request, but the symbol definition has
14837c478bd9Sstevel@tonic-gate * disabled directly binding to it (presumably because the symbol
14847c478bd9Sstevel@tonic-gate * definition has been changed since the referring object was built),
148537ffaf83SRod Evans * reject this binding so that the caller can fall back to a standard
148660758829Srie * symbol search.
14877c478bd9Sstevel@tonic-gate */
14887c478bd9Sstevel@tonic-gate if (sip && (slp->sl_flags & LKUP_DIRECT) &&
14897c478bd9Sstevel@tonic-gate (sip->si_flags & SYMINFO_FLG_NOEXTDIRECT)) {
149060758829Srie DBG_CALL(Dbg_bind_reject(slp->sl_cmap, ilmp, name,
149137ffaf83SRod Evans DBG_BNDREJ_DIRECT));
149260758829Srie *binfo |= BINFO_REJDIRECT;
14937c478bd9Sstevel@tonic-gate *binfo &= ~DBG_BINFO_MSK;
149408278a5eSRod Evans return (0);
149537ffaf83SRod Evans }
149637ffaf83SRod Evans
149737ffaf83SRod Evans /*
149837ffaf83SRod Evans * If this is a binding request within an RTLD_GROUP family, and the
149937ffaf83SRod Evans * symbol has disabled directly binding to it, reject this binding so
150037ffaf83SRod Evans * that the caller can fall back to a standard symbol search.
150137ffaf83SRod Evans *
150237ffaf83SRod Evans * Effectively, an RTLD_GROUP family achieves what can now be
150337ffaf83SRod Evans * established with direct bindings. However, various symbols have
150437ffaf83SRod Evans * been tagged as inappropriate for direct binding to (ie. libc:malloc).
150537ffaf83SRod Evans *
150637ffaf83SRod Evans * A symbol marked as no-direct cannot be used within a group without
150737ffaf83SRod Evans * first ensuring that the symbol has not been interposed upon outside
150837ffaf83SRod Evans * of the group. A common example occurs when users implement their own
150937ffaf83SRod Evans * version of malloc() in the executable. Such a malloc() interposes on
151037ffaf83SRod Evans * the libc:malloc, and this interposition must be honored within the
151137ffaf83SRod Evans * group as well.
151237ffaf83SRod Evans *
151337ffaf83SRod Evans * Following any rejection, LKUP_WORLD is established as a means of
151437ffaf83SRod Evans * overriding this test as we return to a standard search.
151537ffaf83SRod Evans */
151637ffaf83SRod Evans if (sip && (sip->si_flags & SYMINFO_FLG_NOEXTDIRECT) &&
151737ffaf83SRod Evans ((MODE(slp->sl_cmap) & (RTLD_GROUP | RTLD_WORLD)) == RTLD_GROUP) &&
151837ffaf83SRod Evans ((slp->sl_flags & LKUP_WORLD) == 0)) {
151937ffaf83SRod Evans DBG_CALL(Dbg_bind_reject(slp->sl_cmap, ilmp, name,
152037ffaf83SRod Evans DBG_BNDREJ_GROUP));
152137ffaf83SRod Evans *binfo |= BINFO_REJGROUP;
152237ffaf83SRod Evans *binfo &= ~DBG_BINFO_MSK;
152308278a5eSRod Evans return (0);
15247c478bd9Sstevel@tonic-gate }
15257c478bd9Sstevel@tonic-gate
152608278a5eSRod Evans /*
152708278a5eSRod Evans * If this symbol is associated with capabilities, then each of the
152808278a5eSRod Evans * capabilities instances needs to be compared against the system
152908278a5eSRod Evans * capabilities. The best instance will be chosen to satisfy this
153008278a5eSRod Evans * binding.
153108278a5eSRod Evans */
153208278a5eSRod Evans if (CAP(ilmp) && CAPINFO(ilmp) && ELF_C_GROUP(CAPINFO(ilmp)[ndx]) &&
153308278a5eSRod Evans (cap_match(srp, ndx, symtabptr, strtabptr) == 0))
153408278a5eSRod Evans return (0);
153508278a5eSRod Evans
15367c478bd9Sstevel@tonic-gate /*
15377c478bd9Sstevel@tonic-gate * Determine whether this object is acting as a filter.
15387c478bd9Sstevel@tonic-gate */
15397c478bd9Sstevel@tonic-gate if (((flags1 = FLAGS1(ilmp)) & MSK_RT_FILTER) == 0)
154008278a5eSRod Evans return (1);
15417c478bd9Sstevel@tonic-gate
15427c478bd9Sstevel@tonic-gate /*
15437c478bd9Sstevel@tonic-gate * Determine if this object offers per-symbol filtering, and if so,
15447c478bd9Sstevel@tonic-gate * whether this symbol references a filtee.
15457c478bd9Sstevel@tonic-gate */
15467c478bd9Sstevel@tonic-gate if (sip && (flags1 & (FL1_RT_SYMSFLTR | FL1_RT_SYMAFLTR))) {
15477c478bd9Sstevel@tonic-gate /*
15487c478bd9Sstevel@tonic-gate * If this is a standard filter reference, and no standard
15497c478bd9Sstevel@tonic-gate * filtees remain to be inspected, we're done. If this is an
15507c478bd9Sstevel@tonic-gate * auxiliary filter reference, and no auxiliary filtees remain,
15517c478bd9Sstevel@tonic-gate * we'll fall through in case any object filtering is available.
15527c478bd9Sstevel@tonic-gate */
15537c478bd9Sstevel@tonic-gate if ((sip->si_flags & SYMINFO_FLG_FILTER) &&
15547c478bd9Sstevel@tonic-gate (SYMSFLTRCNT(ilmp) == 0))
155508278a5eSRod Evans return (0);
15567c478bd9Sstevel@tonic-gate
15577c478bd9Sstevel@tonic-gate if ((sip->si_flags & SYMINFO_FLG_FILTER) ||
15587c478bd9Sstevel@tonic-gate ((sip->si_flags & SYMINFO_FLG_AUXILIARY) &&
15597c478bd9Sstevel@tonic-gate SYMAFLTRCNT(ilmp))) {
156008278a5eSRod Evans Sresult sr;
156108278a5eSRod Evans
156208278a5eSRod Evans /*
156308278a5eSRod Evans * Initialize a local symbol result descriptor, using
156408278a5eSRod Evans * the original symbol name.
156508278a5eSRod Evans */
156608278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name);
15677c478bd9Sstevel@tonic-gate
15687c478bd9Sstevel@tonic-gate /*
15697c478bd9Sstevel@tonic-gate * This symbol has an associated filtee. Lookup the
15707c478bd9Sstevel@tonic-gate * symbol in the filtee, and if it is found return it.
15717c478bd9Sstevel@tonic-gate * If the symbol doesn't exist, and this is a standard
15727c478bd9Sstevel@tonic-gate * filter, return an error, otherwise fall through to
15737c478bd9Sstevel@tonic-gate * catch any object filtering that may be available.
15747c478bd9Sstevel@tonic-gate */
157508278a5eSRod Evans if (elf_lookup_filtee(slp, &sr, binfo, sip->si_boundto,
157608278a5eSRod Evans in_nfavl)) {
157708278a5eSRod Evans *srp = sr;
157808278a5eSRod Evans return (1);
157908278a5eSRod Evans }
15807c478bd9Sstevel@tonic-gate if (sip->si_flags & SYMINFO_FLG_FILTER)
158108278a5eSRod Evans return (0);
15827c478bd9Sstevel@tonic-gate }
15837c478bd9Sstevel@tonic-gate }
15847c478bd9Sstevel@tonic-gate
15857c478bd9Sstevel@tonic-gate /*
15867c478bd9Sstevel@tonic-gate * Determine if this object provides global filtering.
15877c478bd9Sstevel@tonic-gate */
15887c478bd9Sstevel@tonic-gate if (flags1 & (FL1_RT_OBJSFLTR | FL1_RT_OBJAFLTR)) {
15897c478bd9Sstevel@tonic-gate if (OBJFLTRNDX(ilmp) != FLTR_DISABLED) {
159008278a5eSRod Evans Sresult sr;
159108278a5eSRod Evans
159208278a5eSRod Evans /*
159308278a5eSRod Evans * Initialize a local symbol result descriptor, using
159408278a5eSRod Evans * the original symbol name.
159508278a5eSRod Evans */
159608278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name);
159708278a5eSRod Evans
15987c478bd9Sstevel@tonic-gate /*
15997c478bd9Sstevel@tonic-gate * This object has an associated filtee. Lookup the
16007c478bd9Sstevel@tonic-gate * symbol in the filtee, and if it is found return it.
16017c478bd9Sstevel@tonic-gate * If the symbol doesn't exist, and this is a standard
16027c478bd9Sstevel@tonic-gate * filter, return and error, otherwise return the symbol
16037c478bd9Sstevel@tonic-gate * within the filter itself.
16047c478bd9Sstevel@tonic-gate */
160508278a5eSRod Evans if (elf_lookup_filtee(slp, &sr, binfo, OBJFLTRNDX(ilmp),
160608278a5eSRod Evans in_nfavl)) {
160708278a5eSRod Evans *srp = sr;
160808278a5eSRod Evans return (1);
160908278a5eSRod Evans }
16107c478bd9Sstevel@tonic-gate }
16117c478bd9Sstevel@tonic-gate
16127c478bd9Sstevel@tonic-gate if (flags1 & FL1_RT_OBJSFLTR)
161308278a5eSRod Evans return (0);
16147c478bd9Sstevel@tonic-gate }
161508278a5eSRod Evans return (1);
16167c478bd9Sstevel@tonic-gate }
16177c478bd9Sstevel@tonic-gate
16187c478bd9Sstevel@tonic-gate /*
16197c478bd9Sstevel@tonic-gate * Create a new Rt_map structure for an ELF object and initialize
16207c478bd9Sstevel@tonic-gate * all values.
16217c478bd9Sstevel@tonic-gate */
16227c478bd9Sstevel@tonic-gate Rt_map *
162356deab07SRod Evans elf_new_lmp(Lm_list *lml, Aliste lmco, Fdesc *fdp, Addr addr, size_t msize,
16242020b2b6SRod Evans void *odyn, Rt_map *clmp, int *in_nfavl)
16257c478bd9Sstevel@tonic-gate {
162656deab07SRod Evans const char *name = fdp->fd_nname;
16277c478bd9Sstevel@tonic-gate Rt_map *lmp;
16287c478bd9Sstevel@tonic-gate Ehdr *ehdr = (Ehdr *)addr;
162956deab07SRod Evans Phdr *phdr, *tphdr = NULL, *dphdr = NULL, *uphdr = NULL;
163056deab07SRod Evans Dyn *dyn = (Dyn *)odyn;
163156deab07SRod Evans Cap *cap = NULL;
163256deab07SRod Evans int ndx;
163356deab07SRod Evans Addr base, fltr = 0, audit = 0, cfile = 0, crle = 0;
163456deab07SRod Evans Xword rpath = 0;
163556deab07SRod Evans size_t lmsz, rtsz, epsz, dynsz = 0;
163656deab07SRod Evans uint_t dyncnt = 0;
16377c478bd9Sstevel@tonic-gate
163856deab07SRod Evans DBG_CALL(Dbg_file_elf(lml, name, addr, msize, lml->lm_lmidstr, lmco));
16397c478bd9Sstevel@tonic-gate
16407c478bd9Sstevel@tonic-gate /*
164156deab07SRod Evans * If this is a shared object, the base address of the shared object is
164256deab07SRod Evans * added to all address values defined within the object. Otherwise, if
164356deab07SRod Evans * this is an executable, all object addresses are used as is.
16447c478bd9Sstevel@tonic-gate */
164556deab07SRod Evans if (ehdr->e_type == ET_EXEC)
164656deab07SRod Evans base = 0;
164756deab07SRod Evans else
164856deab07SRod Evans base = addr;
164956deab07SRod Evans
165056deab07SRod Evans /*
165156deab07SRod Evans * Traverse the program header table, picking off required items. This
165256deab07SRod Evans * traversal also provides for the sizing of the PT_DYNAMIC section.
165356deab07SRod Evans */
165456deab07SRod Evans phdr = (Phdr *)((uintptr_t)ehdr + ehdr->e_phoff);
165556deab07SRod Evans for (ndx = 0; ndx < (int)ehdr->e_phnum; ndx++,
165656deab07SRod Evans phdr = (Phdr *)((uintptr_t)phdr + ehdr->e_phentsize)) {
165756deab07SRod Evans switch (phdr->p_type) {
165856deab07SRod Evans case PT_DYNAMIC:
165956deab07SRod Evans dphdr = phdr;
166056deab07SRod Evans dyn = (Dyn *)((uintptr_t)phdr->p_vaddr + base);
166156deab07SRod Evans break;
166256deab07SRod Evans case PT_TLS:
166356deab07SRod Evans tphdr = phdr;
166456deab07SRod Evans break;
166556deab07SRod Evans case PT_SUNWCAP:
166656deab07SRod Evans cap = (Cap *)((uintptr_t)phdr->p_vaddr + base);
166756deab07SRod Evans break;
166856deab07SRod Evans case PT_SUNW_UNWIND:
16697e16fca0SAli Bahrami case PT_SUNW_EH_FRAME:
167056deab07SRod Evans uphdr = phdr;
167156deab07SRod Evans break;
167256deab07SRod Evans default:
167356deab07SRod Evans break;
167456deab07SRod Evans }
16757c478bd9Sstevel@tonic-gate }
16767c478bd9Sstevel@tonic-gate
167756deab07SRod Evans /*
167856deab07SRod Evans * Determine the number of PT_DYNAMIC entries for the DYNINFO()
167956deab07SRod Evans * allocation. Sadly, this is a little larger than we really need,
168056deab07SRod Evans * as there are typically padding DT_NULL entries. However, adding
168156deab07SRod Evans * this data to the initial link-map allocation is a win.
168256deab07SRod Evans */
168356deab07SRod Evans if (dyn) {
168456deab07SRod Evans dyncnt = dphdr->p_filesz / sizeof (Dyn);
168556deab07SRod Evans dynsz = dyncnt * sizeof (Dyninfo);
168656deab07SRod Evans }
168756deab07SRod Evans
168856deab07SRod Evans /*
168956deab07SRod Evans * Allocate space for the link-map, private elf information, and
169056deab07SRod Evans * DYNINFO() data. Once these are allocated and initialized,
169156deab07SRod Evans * remove_so(0, lmp) can be used to tear down the link-map allocation
169256deab07SRod Evans * should any failures occur.
169356deab07SRod Evans */
169456deab07SRod Evans rtsz = S_DROUND(sizeof (Rt_map));
169556deab07SRod Evans epsz = S_DROUND(sizeof (Rt_elfp));
169656deab07SRod Evans lmsz = rtsz + epsz + dynsz;
1697*7eca354dSToomas Soome if ((lmp = calloc(1, lmsz)) == NULL)
169856deab07SRod Evans return (NULL);
169956deab07SRod Evans ELFPRV(lmp) = (void *)((uintptr_t)lmp + rtsz);
170056deab07SRod Evans DYNINFO(lmp) = (Dyninfo *)((uintptr_t)lmp + rtsz + epsz);
170156deab07SRod Evans LMSIZE(lmp) = lmsz;
170256deab07SRod Evans
17037c478bd9Sstevel@tonic-gate /*
17047c478bd9Sstevel@tonic-gate * All fields not filled in were set to 0 by calloc.
17057c478bd9Sstevel@tonic-gate */
170656deab07SRod Evans NAME(lmp) = (char *)name;
17077c478bd9Sstevel@tonic-gate ADDR(lmp) = addr;
17087c478bd9Sstevel@tonic-gate MSIZE(lmp) = msize;
17097c478bd9Sstevel@tonic-gate SYMINTP(lmp) = elf_find_sym;
17107c478bd9Sstevel@tonic-gate FCT(lmp) = &elf_fct;
17117c478bd9Sstevel@tonic-gate LIST(lmp) = lml;
17127c478bd9Sstevel@tonic-gate OBJFLTRNDX(lmp) = FLTR_DISABLED;
1713dffec89cSrie SORTVAL(lmp) = -1;
171456deab07SRod Evans DYN(lmp) = dyn;
171556deab07SRod Evans DYNINFOCNT(lmp) = dyncnt;
171656deab07SRod Evans PTUNWIND(lmp) = uphdr;
17177c478bd9Sstevel@tonic-gate
171856deab07SRod Evans if (ehdr->e_type == ET_EXEC)
17197c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_FIXED;
17207c478bd9Sstevel@tonic-gate
17217c478bd9Sstevel@tonic-gate /*
17227c478bd9Sstevel@tonic-gate * Fill in rest of the link map entries with information from the file's
17237c478bd9Sstevel@tonic-gate * dynamic structure.
17247c478bd9Sstevel@tonic-gate */
172556deab07SRod Evans if (dyn) {
1726f441771bSRod Evans Dyninfo *dip;
1727f441771bSRod Evans uint_t dynndx;
172810a4fa49Srie Xword pltpadsz = 0;
172910a4fa49Srie Rti_desc *rti;
1730f441771bSRod Evans Dyn *pdyn;
1731f441771bSRod Evans Word lmtflags = lml->lm_tflags;
1732f441771bSRod Evans int ignore = 0;
1733f441771bSRod Evans
1734f441771bSRod Evans /*
1735f441771bSRod Evans * Note, we use DT_NULL to terminate processing, and the
1736f441771bSRod Evans * dynamic entry count as a fall back. Normally, a DT_NULL
1737f441771bSRod Evans * entry marks the end of the dynamic section. Any non-NULL
1738f441771bSRod Evans * items following the first DT_NULL are silently ignored.
1739f441771bSRod Evans * This situation should only occur through use of elfedit(1)
1740f441771bSRod Evans * or a similar tool.
1741f441771bSRod Evans */
1742f441771bSRod Evans for (dynndx = 0, pdyn = NULL, dip = DYNINFO(lmp);
1743f441771bSRod Evans dynndx < dyncnt; dynndx++, pdyn = dyn++, dip++) {
1744f441771bSRod Evans
1745f441771bSRod Evans if (ignore) {
1746f441771bSRod Evans dip->di_flags |= FLG_DI_IGNORE;
1747f441771bSRod Evans continue;
1748f441771bSRod Evans }
17497c478bd9Sstevel@tonic-gate
175056deab07SRod Evans switch ((Xword)dyn->d_tag) {
1751f441771bSRod Evans case DT_NULL:
1752f441771bSRod Evans dip->di_flags |= ignore = FLG_DI_IGNORE;
1753f441771bSRod Evans break;
1754f441771bSRod Evans case DT_POSFLAG_1:
1755f441771bSRod Evans dip->di_flags |= FLG_DI_POSFLAG1;
1756f441771bSRod Evans break;
1757f441771bSRod Evans case DT_NEEDED:
1758f441771bSRod Evans case DT_USED:
1759f441771bSRod Evans dip->di_flags |= FLG_DI_NEEDED;
1760f441771bSRod Evans
1761f441771bSRod Evans /* BEGIN CSTYLED */
1762f441771bSRod Evans if (pdyn && (pdyn->d_tag == DT_POSFLAG_1)) {
1763f441771bSRod Evans /*
1764f441771bSRod Evans * Identify any non-deferred lazy load for
1765f441771bSRod Evans * future processing, unless LD_NOLAZYLOAD
1766f441771bSRod Evans * has been set.
1767f441771bSRod Evans */
1768f441771bSRod Evans if ((pdyn->d_un.d_val & DF_P1_LAZYLOAD) &&
1769f441771bSRod Evans ((lmtflags & LML_TFLG_NOLAZYLD) == 0))
1770f441771bSRod Evans dip->di_flags |= FLG_DI_LAZY;
1771f441771bSRod Evans
1772f441771bSRod Evans /*
1773f441771bSRod Evans * Identify any group permission
1774f441771bSRod Evans * requirements.
1775f441771bSRod Evans */
1776f441771bSRod Evans if (pdyn->d_un.d_val & DF_P1_GROUPPERM)
1777f441771bSRod Evans dip->di_flags |= FLG_DI_GROUP;
1778f441771bSRod Evans
1779f441771bSRod Evans /*
1780f441771bSRod Evans * Identify any deferred dependencies.
1781f441771bSRod Evans */
1782f441771bSRod Evans if (pdyn->d_un.d_val & DF_P1_DEFERRED)
1783f441771bSRod Evans dip->di_flags |= FLG_DI_DEFERRED;
1784f441771bSRod Evans }
1785f441771bSRod Evans /* END CSTYLED */
1786f441771bSRod Evans break;
17877c478bd9Sstevel@tonic-gate case DT_SYMTAB:
178856deab07SRod Evans SYMTAB(lmp) = (void *)(dyn->d_un.d_ptr + base);
17897c478bd9Sstevel@tonic-gate break;
17909039eeafSab case DT_SUNW_SYMTAB:
17919039eeafSab SUNWSYMTAB(lmp) =
179256deab07SRod Evans (void *)(dyn->d_un.d_ptr + base);
17939039eeafSab break;
17949039eeafSab case DT_SUNW_SYMSZ:
179556deab07SRod Evans SUNWSYMSZ(lmp) = dyn->d_un.d_val;
17969039eeafSab break;
17977c478bd9Sstevel@tonic-gate case DT_STRTAB:
179856deab07SRod Evans STRTAB(lmp) = (void *)(dyn->d_un.d_ptr + base);
17997c478bd9Sstevel@tonic-gate break;
18007c478bd9Sstevel@tonic-gate case DT_SYMENT:
180156deab07SRod Evans SYMENT(lmp) = dyn->d_un.d_val;
18027c478bd9Sstevel@tonic-gate break;
18037c478bd9Sstevel@tonic-gate case DT_FEATURE_1:
180456deab07SRod Evans if (dyn->d_un.d_val & DTF_1_CONFEXP)
18057c478bd9Sstevel@tonic-gate crle = 1;
18067c478bd9Sstevel@tonic-gate break;
18077c478bd9Sstevel@tonic-gate case DT_MOVESZ:
180856deab07SRod Evans MOVESZ(lmp) = dyn->d_un.d_val;
18097c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_MOVE;
18107c478bd9Sstevel@tonic-gate break;
18117c478bd9Sstevel@tonic-gate case DT_MOVEENT:
181256deab07SRod Evans MOVEENT(lmp) = dyn->d_un.d_val;
18137c478bd9Sstevel@tonic-gate break;
18147c478bd9Sstevel@tonic-gate case DT_MOVETAB:
181556deab07SRod Evans MOVETAB(lmp) = (void *)(dyn->d_un.d_ptr + base);
18167c478bd9Sstevel@tonic-gate break;
18177c478bd9Sstevel@tonic-gate case DT_REL:
18187c478bd9Sstevel@tonic-gate case DT_RELA:
18197c478bd9Sstevel@tonic-gate /*
182075e7992aSrie * At this time, ld.so. can only handle one
182175e7992aSrie * type of relocation per object.
18227c478bd9Sstevel@tonic-gate */
182356deab07SRod Evans REL(lmp) = (void *)(dyn->d_un.d_ptr + base);
18247c478bd9Sstevel@tonic-gate break;
18257c478bd9Sstevel@tonic-gate case DT_RELSZ:
18267c478bd9Sstevel@tonic-gate case DT_RELASZ:
182756deab07SRod Evans RELSZ(lmp) = dyn->d_un.d_val;
18287c478bd9Sstevel@tonic-gate break;
18297c478bd9Sstevel@tonic-gate case DT_RELENT:
18307c478bd9Sstevel@tonic-gate case DT_RELAENT:
183156deab07SRod Evans RELENT(lmp) = dyn->d_un.d_val;
18327c478bd9Sstevel@tonic-gate break;
18337c478bd9Sstevel@tonic-gate case DT_RELCOUNT:
18347c478bd9Sstevel@tonic-gate case DT_RELACOUNT:
183556deab07SRod Evans RELACOUNT(lmp) = (uint_t)dyn->d_un.d_val;
18367c478bd9Sstevel@tonic-gate break;
18377c478bd9Sstevel@tonic-gate case DT_HASH:
183856deab07SRod Evans HASH(lmp) = (uint_t *)(dyn->d_un.d_ptr + base);
18397c478bd9Sstevel@tonic-gate break;
18407c478bd9Sstevel@tonic-gate case DT_PLTGOT:
184156deab07SRod Evans PLTGOT(lmp) =
184256deab07SRod Evans (uint_t *)(dyn->d_un.d_ptr + base);
18437c478bd9Sstevel@tonic-gate break;
18447c478bd9Sstevel@tonic-gate case DT_PLTRELSZ:
184556deab07SRod Evans PLTRELSZ(lmp) = dyn->d_un.d_val;
18467c478bd9Sstevel@tonic-gate break;
18477c478bd9Sstevel@tonic-gate case DT_JMPREL:
184856deab07SRod Evans JMPREL(lmp) = (void *)(dyn->d_un.d_ptr + base);
18497c478bd9Sstevel@tonic-gate break;
18507c478bd9Sstevel@tonic-gate case DT_INIT:
185167d74cc3SToomas Soome if (dyn->d_un.d_ptr != 0)
18525b59e4caSab INIT(lmp) =
185356deab07SRod Evans (void (*)())(dyn->d_un.d_ptr +
185456deab07SRod Evans base);
18557c478bd9Sstevel@tonic-gate break;
18567c478bd9Sstevel@tonic-gate case DT_FINI:
185767d74cc3SToomas Soome if (dyn->d_un.d_ptr != 0)
18585b59e4caSab FINI(lmp) =
185956deab07SRod Evans (void (*)())(dyn->d_un.d_ptr +
186056deab07SRod Evans base);
18617c478bd9Sstevel@tonic-gate break;
18627c478bd9Sstevel@tonic-gate case DT_INIT_ARRAY:
186356deab07SRod Evans INITARRAY(lmp) = (Addr *)(dyn->d_un.d_ptr +
18647c478bd9Sstevel@tonic-gate base);
18657c478bd9Sstevel@tonic-gate break;
18667c478bd9Sstevel@tonic-gate case DT_INIT_ARRAYSZ:
186756deab07SRod Evans INITARRAYSZ(lmp) = (uint_t)dyn->d_un.d_val;
18687c478bd9Sstevel@tonic-gate break;
18697c478bd9Sstevel@tonic-gate case DT_FINI_ARRAY:
187056deab07SRod Evans FINIARRAY(lmp) = (Addr *)(dyn->d_un.d_ptr +
18717c478bd9Sstevel@tonic-gate base);
18727c478bd9Sstevel@tonic-gate break;
18737c478bd9Sstevel@tonic-gate case DT_FINI_ARRAYSZ:
187456deab07SRod Evans FINIARRAYSZ(lmp) = (uint_t)dyn->d_un.d_val;
18757c478bd9Sstevel@tonic-gate break;
18767c478bd9Sstevel@tonic-gate case DT_PREINIT_ARRAY:
187756deab07SRod Evans PREINITARRAY(lmp) = (Addr *)(dyn->d_un.d_ptr +
18787c478bd9Sstevel@tonic-gate base);
18797c478bd9Sstevel@tonic-gate break;
18807c478bd9Sstevel@tonic-gate case DT_PREINIT_ARRAYSZ:
188156deab07SRod Evans PREINITARRAYSZ(lmp) = (uint_t)dyn->d_un.d_val;
18827c478bd9Sstevel@tonic-gate break;
18837c478bd9Sstevel@tonic-gate case DT_RPATH:
18847c478bd9Sstevel@tonic-gate case DT_RUNPATH:
188556deab07SRod Evans rpath = dyn->d_un.d_val;
18867c478bd9Sstevel@tonic-gate break;
18877c478bd9Sstevel@tonic-gate case DT_FILTER:
1888f441771bSRod Evans dip->di_flags |= FLG_DI_STDFLTR;
188956deab07SRod Evans fltr = dyn->d_un.d_val;
189075e7992aSrie OBJFLTRNDX(lmp) = dynndx;
18917c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_OBJSFLTR;
18927c478bd9Sstevel@tonic-gate break;
18937c478bd9Sstevel@tonic-gate case DT_AUXILIARY:
1894f441771bSRod Evans dip->di_flags |= FLG_DI_AUXFLTR;
18957c478bd9Sstevel@tonic-gate if (!(rtld_flags & RT_FL_NOAUXFLTR)) {
189656deab07SRod Evans fltr = dyn->d_un.d_val;
189775e7992aSrie OBJFLTRNDX(lmp) = dynndx;
18987c478bd9Sstevel@tonic-gate }
18997c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_OBJAFLTR;
19007c478bd9Sstevel@tonic-gate break;
19017c478bd9Sstevel@tonic-gate case DT_SUNW_FILTER:
1902f441771bSRod Evans dip->di_flags |=
1903f441771bSRod Evans (FLG_DI_STDFLTR | FLG_DI_SYMFLTR);
19047c478bd9Sstevel@tonic-gate SYMSFLTRCNT(lmp)++;
19057c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_SYMSFLTR;
19067c478bd9Sstevel@tonic-gate break;
19077c478bd9Sstevel@tonic-gate case DT_SUNW_AUXILIARY:
1908f441771bSRod Evans dip->di_flags |=
1909f441771bSRod Evans (FLG_DI_AUXFLTR | FLG_DI_SYMFLTR);
19107c478bd9Sstevel@tonic-gate if (!(rtld_flags & RT_FL_NOAUXFLTR)) {
19117c478bd9Sstevel@tonic-gate SYMAFLTRCNT(lmp)++;
19127c478bd9Sstevel@tonic-gate }
19137c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_SYMAFLTR;
19147c478bd9Sstevel@tonic-gate break;
19157c478bd9Sstevel@tonic-gate case DT_DEPAUDIT:
1916b533f56bSRobert Mustacchi if (!(rtld_flags & RT_FL_NOAUDIT)) {
191756deab07SRod Evans audit = dyn->d_un.d_val;
1918b533f56bSRobert Mustacchi FLAGS1(lmp) |= FL1_RT_DEPAUD;
1919b533f56bSRobert Mustacchi }
19207c478bd9Sstevel@tonic-gate break;
19217c478bd9Sstevel@tonic-gate case DT_CONFIG:
192256deab07SRod Evans cfile = dyn->d_un.d_val;
19237c478bd9Sstevel@tonic-gate break;
19247c478bd9Sstevel@tonic-gate case DT_DEBUG:
19257c478bd9Sstevel@tonic-gate /*
19267c478bd9Sstevel@tonic-gate * DT_DEBUG entries are only created in
19277c478bd9Sstevel@tonic-gate * dynamic objects that require an interpretor
19287c478bd9Sstevel@tonic-gate * (ie. all dynamic executables and some shared
19297c478bd9Sstevel@tonic-gate * objects), and provide for a hand-shake with
1930dde769a2SRod Evans * old debuggers. This entry is initialized to
1931dde769a2SRod Evans * zero by the link-editor. If a debugger is
1932dde769a2SRod Evans * monitoring us, and has updated this entry,
1933dde769a2SRod Evans * set the debugger monitor flag, and finish
1934dde769a2SRod Evans * initializing the debugging structure. See
1935dde769a2SRod Evans * setup(). Also, switch off any configuration
1936dde769a2SRod Evans * object use as most debuggers can't handle
1937dde769a2SRod Evans * fixed dynamic executables as dependencies.
19387c478bd9Sstevel@tonic-gate */
193956deab07SRod Evans if (dyn->d_un.d_ptr)
19407c478bd9Sstevel@tonic-gate rtld_flags |=
19417c478bd9Sstevel@tonic-gate (RT_FL_DEBUGGER | RT_FL_NOOBJALT);
194256deab07SRod Evans dyn->d_un.d_ptr = (Addr)&r_debug;
19437c478bd9Sstevel@tonic-gate break;
19447c478bd9Sstevel@tonic-gate case DT_VERNEED:
194556deab07SRod Evans VERNEED(lmp) = (Verneed *)(dyn->d_un.d_ptr +
19467c478bd9Sstevel@tonic-gate base);
19477c478bd9Sstevel@tonic-gate break;
19487c478bd9Sstevel@tonic-gate case DT_VERNEEDNUM:
19497c478bd9Sstevel@tonic-gate /* LINTED */
195056deab07SRod Evans VERNEEDNUM(lmp) = (int)dyn->d_un.d_val;
19517c478bd9Sstevel@tonic-gate break;
19527c478bd9Sstevel@tonic-gate case DT_VERDEF:
195356deab07SRod Evans VERDEF(lmp) = (Verdef *)(dyn->d_un.d_ptr +
195456deab07SRod Evans base);
19557c478bd9Sstevel@tonic-gate break;
19567c478bd9Sstevel@tonic-gate case DT_VERDEFNUM:
19577c478bd9Sstevel@tonic-gate /* LINTED */
195856deab07SRod Evans VERDEFNUM(lmp) = (int)dyn->d_un.d_val;
19597c478bd9Sstevel@tonic-gate break;
19603b41b08bSab case DT_VERSYM:
1961d840867fSab /*
1962d840867fSab * The Solaris ld does not produce DT_VERSYM,
1963d840867fSab * but the GNU ld does, in order to support
1964d840867fSab * their style of versioning, which differs
1965d840867fSab * from ours in some ways, while using the
1966d840867fSab * same data structures. The presence of
1967d840867fSab * DT_VERSYM therefore means that GNU
1968d840867fSab * versioning rules apply to the given file.
1969d840867fSab * If DT_VERSYM is not present, then Solaris
1970d840867fSab * versioning rules apply.
1971d840867fSab */
197256deab07SRod Evans VERSYM(lmp) = (Versym *)(dyn->d_un.d_ptr +
197356deab07SRod Evans base);
19743b41b08bSab break;
19757c478bd9Sstevel@tonic-gate case DT_BIND_NOW:
197656deab07SRod Evans if ((dyn->d_un.d_val & DF_BIND_NOW) &&
197756deab07SRod Evans ((rtld_flags2 & RT_FL2_BINDLAZY) == 0)) {
19787c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_NOW;
19797c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_LAZY;
19807c478bd9Sstevel@tonic-gate }
19817c478bd9Sstevel@tonic-gate break;
19827c478bd9Sstevel@tonic-gate case DT_FLAGS:
198356deab07SRod Evans FLAGS1(lmp) |= FL1_RT_DTFLAGS;
198456deab07SRod Evans if (dyn->d_un.d_val & DF_SYMBOLIC)
19857c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_SYMBOLIC;
198656deab07SRod Evans if ((dyn->d_un.d_val & DF_BIND_NOW) &&
1987dffec89cSrie ((rtld_flags2 & RT_FL2_BINDLAZY) == 0)) {
19887c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_NOW;
19897c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_LAZY;
19907c478bd9Sstevel@tonic-gate }
1991d326b23bSrie /*
1992d326b23bSrie * Capture any static TLS use, and enforce that
1993d326b23bSrie * this object be non-deletable.
1994d326b23bSrie */
199556deab07SRod Evans if (dyn->d_un.d_val & DF_STATIC_TLS) {
1996d326b23bSrie FLAGS1(lmp) |= FL1_RT_TLSSTAT;
1997d326b23bSrie MODE(lmp) |= RTLD_NODELETE;
1998d326b23bSrie }
19997c478bd9Sstevel@tonic-gate break;
20007c478bd9Sstevel@tonic-gate case DT_FLAGS_1:
200156deab07SRod Evans if (dyn->d_un.d_val & DF_1_DISPRELPND)
20027c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_DISPREL;
200356deab07SRod Evans if (dyn->d_un.d_val & DF_1_GROUP)
20047c478bd9Sstevel@tonic-gate FLAGS(lmp) |=
20052017c965SRod Evans (FLG_RT_SETGROUP | FLG_RT_PUBHDL);
200656deab07SRod Evans if ((dyn->d_un.d_val & DF_1_NOW) &&
2007dffec89cSrie ((rtld_flags2 & RT_FL2_BINDLAZY) == 0)) {
20087c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_NOW;
20097c478bd9Sstevel@tonic-gate MODE(lmp) &= ~RTLD_LAZY;
20107c478bd9Sstevel@tonic-gate }
201156deab07SRod Evans if (dyn->d_un.d_val & DF_1_NODELETE)
20127c478bd9Sstevel@tonic-gate MODE(lmp) |= RTLD_NODELETE;
201356deab07SRod Evans if (dyn->d_un.d_val & DF_1_INITFIRST)
20147c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_INITFRST;
201556deab07SRod Evans if (dyn->d_un.d_val & DF_1_NOOPEN)
20167c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_NOOPEN;
201756deab07SRod Evans if (dyn->d_un.d_val & DF_1_LOADFLTR)
20187c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_LOADFLTR;
201956deab07SRod Evans if (dyn->d_un.d_val & DF_1_NODUMP)
20207c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_NODUMP;
202156deab07SRod Evans if (dyn->d_un.d_val & DF_1_CONFALT)
20227c478bd9Sstevel@tonic-gate crle = 1;
202356deab07SRod Evans if (dyn->d_un.d_val & DF_1_DIRECT)
20249a411307Srie FLAGS1(lmp) |= FL1_RT_DIRECT;
202556deab07SRod Evans if (dyn->d_un.d_val & DF_1_NODEFLIB)
20267c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_NODEFLIB;
202756deab07SRod Evans if (dyn->d_un.d_val & DF_1_ENDFILTEE)
20287c478bd9Sstevel@tonic-gate FLAGS1(lmp) |= FL1_RT_ENDFILTE;
202956deab07SRod Evans if (dyn->d_un.d_val & DF_1_TRANS)
20307c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_TRANS;
203156deab07SRod Evans
20327247f888Srie /*
20337247f888Srie * Global auditing is only meaningful when
20347247f888Srie * specified by the initiating object of the
20357247f888Srie * process - typically the dynamic executable.
203608278a5eSRod Evans * If this is the initiating object, its link-
20377247f888Srie * map will not yet have been added to the
20387247f888Srie * link-map list, and consequently the link-map
20397247f888Srie * list is empty. (see setup()).
20407247f888Srie */
204156deab07SRod Evans if (dyn->d_un.d_val & DF_1_GLOBAUDIT) {
2042481bba9eSRod Evans if (lml_main.lm_head == NULL)
20437247f888Srie FLAGS1(lmp) |= FL1_RT_GLOBAUD;
20447247f888Srie else
20457247f888Srie DBG_CALL(Dbg_audit_ignore(lmp));
20467247f888Srie }
20477247f888Srie
20487c478bd9Sstevel@tonic-gate /*
20497c478bd9Sstevel@tonic-gate * If this object identifies itself as an
20507c478bd9Sstevel@tonic-gate * interposer, but relocation processing has
20517c478bd9Sstevel@tonic-gate * already started, then demote it. It's too
20527c478bd9Sstevel@tonic-gate * late to guarantee complete interposition.
20537c478bd9Sstevel@tonic-gate */
2054a953e2b1Srie /* BEGIN CSTYLED */
205556deab07SRod Evans if (dyn->d_un.d_val &
20569a411307Srie (DF_1_INTERPOSE | DF_1_SYMINTPOSE)) {
20579a411307Srie if (lml->lm_flags & LML_FLG_STARTREL) {
20585aefb655Srie DBG_CALL(Dbg_util_intoolate(lmp));
20597c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_ENABLE)
20607c478bd9Sstevel@tonic-gate (void) printf(
20617c478bd9Sstevel@tonic-gate MSG_INTL(MSG_LDD_REL_ERR2),
20627c478bd9Sstevel@tonic-gate NAME(lmp));
206356deab07SRod Evans } else if (dyn->d_un.d_val & DF_1_INTERPOSE)
20649a411307Srie FLAGS(lmp) |= FLG_RT_OBJINTPO;
20659a411307Srie else
20669a411307Srie FLAGS(lmp) |= FLG_RT_SYMINTPO;
20677c478bd9Sstevel@tonic-gate }
2068a953e2b1Srie /* END CSTYLED */
20697c478bd9Sstevel@tonic-gate break;
20707c478bd9Sstevel@tonic-gate case DT_SYMINFO:
207156deab07SRod Evans SYMINFO(lmp) = (Syminfo *)(dyn->d_un.d_ptr +
20727c478bd9Sstevel@tonic-gate base);
20737c478bd9Sstevel@tonic-gate break;
20747c478bd9Sstevel@tonic-gate case DT_SYMINENT:
207556deab07SRod Evans SYMINENT(lmp) = dyn->d_un.d_val;
20767c478bd9Sstevel@tonic-gate break;
20777c478bd9Sstevel@tonic-gate case DT_PLTPAD:
207856deab07SRod Evans PLTPAD(lmp) = (void *)(dyn->d_un.d_ptr + base);
20797c478bd9Sstevel@tonic-gate break;
20807c478bd9Sstevel@tonic-gate case DT_PLTPADSZ:
208156deab07SRod Evans pltpadsz = dyn->d_un.d_val;
20827c478bd9Sstevel@tonic-gate break;
20837c478bd9Sstevel@tonic-gate case DT_SUNW_RTLDINF:
20847c478bd9Sstevel@tonic-gate /*
208510a4fa49Srie * Maintain a list of RTLDINFO structures.
208610a4fa49Srie * Typically, libc is the only supplier, and
208710a4fa49Srie * only one structure is provided. However,
208810a4fa49Srie * multiple suppliers and multiple structures
208910a4fa49Srie * are supported. For example, one structure
209010a4fa49Srie * may provide thread_init, and another
209110a4fa49Srie * structure may provide atexit reservations.
20927c478bd9Sstevel@tonic-gate */
2093dde769a2SRod Evans if ((rti = alist_append(&lml->lm_rti, NULL,
209456deab07SRod Evans sizeof (Rti_desc),
209556deab07SRod Evans AL_CNT_RTLDINFO)) == NULL) {
20962020b2b6SRod Evans remove_so(0, lmp, clmp);
209756deab07SRod Evans return (NULL);
20987c478bd9Sstevel@tonic-gate }
209910a4fa49Srie rti->rti_lmp = lmp;
210056deab07SRod Evans rti->rti_info = (void *)(dyn->d_un.d_ptr +
210156deab07SRod Evans base);
21027c478bd9Sstevel@tonic-gate break;
2103d579eb63Sab case DT_SUNW_SORTENT:
210456deab07SRod Evans SUNWSORTENT(lmp) = dyn->d_un.d_val;
2105d579eb63Sab break;
2106d579eb63Sab case DT_SUNW_SYMSORT:
2107d579eb63Sab SUNWSYMSORT(lmp) =
210856deab07SRod Evans (void *)(dyn->d_un.d_ptr + base);
2109d579eb63Sab break;
2110d579eb63Sab case DT_SUNW_SYMSORTSZ:
211156deab07SRod Evans SUNWSYMSORTSZ(lmp) = dyn->d_un.d_val;
2112d579eb63Sab break;
21137c478bd9Sstevel@tonic-gate case DT_DEPRECATED_SPARC_REGISTER:
21147c478bd9Sstevel@tonic-gate case M_DT_REGISTER:
2115f441771bSRod Evans dip->di_flags |= FLG_DI_REGISTER;
21167c478bd9Sstevel@tonic-gate FLAGS(lmp) |= FLG_RT_REGSYMS;
21177c478bd9Sstevel@tonic-gate break;
211808278a5eSRod Evans case DT_SUNW_CAP:
211908278a5eSRod Evans CAP(lmp) = (void *)(dyn->d_un.d_ptr + base);
212008278a5eSRod Evans break;
212108278a5eSRod Evans case DT_SUNW_CAPINFO:
212208278a5eSRod Evans CAPINFO(lmp) = (void *)(dyn->d_un.d_ptr + base);
212308278a5eSRod Evans break;
212408278a5eSRod Evans case DT_SUNW_CAPCHAIN:
212508278a5eSRod Evans CAPCHAIN(lmp) = (void *)(dyn->d_un.d_ptr +
212608278a5eSRod Evans base);
212708278a5eSRod Evans break;
212808278a5eSRod Evans case DT_SUNW_CAPCHAINENT:
212908278a5eSRod Evans CAPCHAINENT(lmp) = dyn->d_un.d_val;
213008278a5eSRod Evans break;
213108278a5eSRod Evans case DT_SUNW_CAPCHAINSZ:
213208278a5eSRod Evans CAPCHAINSZ(lmp) = dyn->d_un.d_val;
213308278a5eSRod Evans break;
21347c478bd9Sstevel@tonic-gate }
21357c478bd9Sstevel@tonic-gate }
21367c478bd9Sstevel@tonic-gate
2137f441771bSRod Evans /*
2138f441771bSRod Evans * Update any Dyninfo string pointers now that STRTAB() is
2139f441771bSRod Evans * known.
2140f441771bSRod Evans */
2141f441771bSRod Evans for (dynndx = 0, dyn = DYN(lmp), dip = DYNINFO(lmp);
2142f441771bSRod Evans !(dip->di_flags & FLG_DI_IGNORE); dyn++, dip++) {
2143f441771bSRod Evans
2144f441771bSRod Evans switch ((Xword)dyn->d_tag) {
2145f441771bSRod Evans case DT_NEEDED:
2146f441771bSRod Evans case DT_USED:
2147f441771bSRod Evans case DT_FILTER:
2148f441771bSRod Evans case DT_AUXILIARY:
2149f441771bSRod Evans case DT_SUNW_FILTER:
2150f441771bSRod Evans case DT_SUNW_AUXILIARY:
2151f441771bSRod Evans dip->di_name = STRTAB(lmp) + dyn->d_un.d_val;
2152f441771bSRod Evans break;
2153f441771bSRod Evans }
2154f441771bSRod Evans }
2155f441771bSRod Evans
2156f441771bSRod Evans /*
2157f441771bSRod Evans * Assign any padding.
2158f441771bSRod Evans */
21597c478bd9Sstevel@tonic-gate if (PLTPAD(lmp)) {
21607c478bd9Sstevel@tonic-gate if (pltpadsz == (Xword)0)
2161481bba9eSRod Evans PLTPAD(lmp) = NULL;
21627c478bd9Sstevel@tonic-gate else
21637c478bd9Sstevel@tonic-gate PLTPADEND(lmp) = (void *)((Addr)PLTPAD(lmp) +
21647c478bd9Sstevel@tonic-gate pltpadsz);
21657c478bd9Sstevel@tonic-gate }
21667c478bd9Sstevel@tonic-gate }
21677c478bd9Sstevel@tonic-gate
21689039eeafSab /*
21699039eeafSab * A dynsym contains only global functions. We want to have
21709039eeafSab * a version of it that also includes local functions, so that
21719039eeafSab * dladdr() will be able to report names for local functions
21729039eeafSab * when used to generate a stack trace for a stripped file.
21739039eeafSab * This version of the dynsym is provided via DT_SUNW_SYMTAB.
21749039eeafSab *
21759039eeafSab * In producing DT_SUNW_SYMTAB, ld uses a non-obvious trick
21769039eeafSab * in order to avoid having to have two copies of the global
21779039eeafSab * symbols held in DT_SYMTAB: The local symbols are placed in
21789039eeafSab * a separate section than the globals in the dynsym, but the
21799039eeafSab * linker conspires to put the data for these two sections adjacent
21809039eeafSab * to each other. DT_SUNW_SYMTAB points at the top of the local
21819039eeafSab * symbols, and DT_SUNW_SYMSZ is the combined length of both tables.
21829039eeafSab *
21839039eeafSab * If the two sections are not adjacent, then something went wrong
21849039eeafSab * at link time. We use ASSERT to kill the process if this is
21859039eeafSab * a debug build. In a production build, we will silently ignore
21869039eeafSab * the presence of the .ldynsym and proceed. We can detect this
21879039eeafSab * situation by checking to see that DT_SYMTAB lies in
21889039eeafSab * the range given by DT_SUNW_SYMTAB/DT_SUNW_SYMSZ.
21899039eeafSab */
21909039eeafSab if ((SUNWSYMTAB(lmp) != NULL) &&
21919039eeafSab (((char *)SYMTAB(lmp) <= (char *)SUNWSYMTAB(lmp)) ||
21929039eeafSab (((char *)SYMTAB(lmp) >=
21939039eeafSab (SUNWSYMSZ(lmp) + (char *)SUNWSYMTAB(lmp)))))) {
21949039eeafSab ASSERT(0);
21959039eeafSab SUNWSYMTAB(lmp) = NULL;
21969039eeafSab SUNWSYMSZ(lmp) = 0;
21979039eeafSab }
21989039eeafSab
21997c478bd9Sstevel@tonic-gate /*
22007c478bd9Sstevel@tonic-gate * If configuration file use hasn't been disabled, and a configuration
22017c478bd9Sstevel@tonic-gate * file hasn't already been set via an environment variable, see if any
22027c478bd9Sstevel@tonic-gate * application specific configuration file is specified. An LD_CONFIG
22037c478bd9Sstevel@tonic-gate * setting is used first, but if this image was generated via crle(1)
22047c478bd9Sstevel@tonic-gate * then a default configuration file is a fall-back.
22057c478bd9Sstevel@tonic-gate */
2206481bba9eSRod Evans if ((!(rtld_flags & RT_FL_NOCFG)) && (config->c_name == NULL)) {
22077c478bd9Sstevel@tonic-gate if (cfile)
22087c478bd9Sstevel@tonic-gate config->c_name = (const char *)(cfile +
22097c478bd9Sstevel@tonic-gate (char *)STRTAB(lmp));
221056deab07SRod Evans else if (crle)
22117c478bd9Sstevel@tonic-gate rtld_flags |= RT_FL_CONFAPP;
22127c478bd9Sstevel@tonic-gate }
22137c478bd9Sstevel@tonic-gate
22147c478bd9Sstevel@tonic-gate if (rpath)
22157c478bd9Sstevel@tonic-gate RPATH(lmp) = (char *)(rpath + (char *)STRTAB(lmp));
221656deab07SRod Evans if (fltr)
221756deab07SRod Evans REFNAME(lmp) = (char *)(fltr + (char *)STRTAB(lmp));
22187c478bd9Sstevel@tonic-gate
22197c478bd9Sstevel@tonic-gate /*
22207c478bd9Sstevel@tonic-gate * For Intel ABI compatibility. It's possible that a JMPREL can be
22217c478bd9Sstevel@tonic-gate * specified without any other relocations (e.g. a dynamic executable
22227c478bd9Sstevel@tonic-gate * normally only contains .plt relocations). If this is the case then
22237c478bd9Sstevel@tonic-gate * no REL, RELSZ or RELENT will have been created. For us to be able
22247c478bd9Sstevel@tonic-gate * to traverse the .plt relocations under LD_BIND_NOW we need to know
22257c478bd9Sstevel@tonic-gate * the RELENT for these relocations. Refer to elf_reloc() for more
22267c478bd9Sstevel@tonic-gate * details.
22277c478bd9Sstevel@tonic-gate */
22287c478bd9Sstevel@tonic-gate if (!RELENT(lmp) && JMPREL(lmp))
222956deab07SRod Evans RELENT(lmp) = sizeof (M_RELOC);
22307c478bd9Sstevel@tonic-gate
22317c478bd9Sstevel@tonic-gate /*
2232f441771bSRod Evans * Establish any per-object auditing. If we're establishing main's
22337c478bd9Sstevel@tonic-gate * link-map its too early to go searching for audit objects so just
22347c478bd9Sstevel@tonic-gate * hold the object name for later (see setup()).
22357c478bd9Sstevel@tonic-gate */
22367c478bd9Sstevel@tonic-gate if (audit) {
22377c478bd9Sstevel@tonic-gate char *cp = audit + (char *)STRTAB(lmp);
22387c478bd9Sstevel@tonic-gate
22397c478bd9Sstevel@tonic-gate if (*cp) {
22407c478bd9Sstevel@tonic-gate if (((AUDITORS(lmp) =
224156deab07SRod Evans calloc(1, sizeof (Audit_desc))) == NULL) ||
224256deab07SRod Evans ((AUDITORS(lmp)->ad_name = strdup(cp)) == NULL)) {
22432020b2b6SRod Evans remove_so(0, lmp, clmp);
224456deab07SRod Evans return (NULL);
22457c478bd9Sstevel@tonic-gate }
224641072f3cSrie if (lml_main.lm_head) {
22479aa23310Srie if (audit_setup(lmp, AUDITORS(lmp), 0,
22489aa23310Srie in_nfavl) == 0) {
22492020b2b6SRod Evans remove_so(0, lmp, clmp);
225056deab07SRod Evans return (NULL);
22517c478bd9Sstevel@tonic-gate }
225256deab07SRod Evans AFLAGS(lmp) |= AUDITORS(lmp)->ad_flags;
22537c478bd9Sstevel@tonic-gate lml->lm_flags |= LML_FLG_LOCAUDIT;
22547c478bd9Sstevel@tonic-gate }
22557c478bd9Sstevel@tonic-gate }
22567c478bd9Sstevel@tonic-gate }
22577c478bd9Sstevel@tonic-gate
225856deab07SRod Evans if (tphdr && (tls_assign(lml, lmp, tphdr) == 0)) {
22592020b2b6SRod Evans remove_so(0, lmp, clmp);
226056deab07SRod Evans return (NULL);
22617c478bd9Sstevel@tonic-gate }
22627c478bd9Sstevel@tonic-gate
226308278a5eSRod Evans /*
226408278a5eSRod Evans * A capabilities section should be identified by a DT_SUNW_CAP entry,
226508278a5eSRod Evans * and if non-empty object capabilities are included, a PT_SUNWCAP
226608278a5eSRod Evans * header should reference the section. Make sure CAP() is set
226708278a5eSRod Evans * regardless.
226808278a5eSRod Evans */
226908278a5eSRod Evans if ((CAP(lmp) == NULL) && cap)
227008278a5eSRod Evans CAP(lmp) = cap;
227108278a5eSRod Evans
227208278a5eSRod Evans /*
227308278a5eSRod Evans * Make sure any capabilities information or chain can be handled.
227408278a5eSRod Evans */
227508278a5eSRod Evans if (CAPINFO(lmp) && (CAPINFO(lmp)[0] > CAPINFO_CURRENT))
227608278a5eSRod Evans CAPINFO(lmp) = NULL;
227708278a5eSRod Evans if (CAPCHAIN(lmp) && (CAPCHAIN(lmp)[0] > CAPCHAIN_CURRENT))
227808278a5eSRod Evans CAPCHAIN(lmp) = NULL;
227908278a5eSRod Evans
228008278a5eSRod Evans /*
228108278a5eSRod Evans * As part of processing dependencies, a file descriptor is populated
228208278a5eSRod Evans * with capabilities information following validation.
228308278a5eSRod Evans */
228408278a5eSRod Evans if (fdp->fd_flags & FLG_FD_ALTCHECK) {
228508278a5eSRod Evans FLAGS1(lmp) |= FL1_RT_ALTCHECK;
228608278a5eSRod Evans CAPSET(lmp) = fdp->fd_scapset;
228708278a5eSRod Evans
228808278a5eSRod Evans if (fdp->fd_flags & FLG_FD_ALTCAP)
228908278a5eSRod Evans FLAGS1(lmp) |= FL1_RT_ALTCAP;
229008278a5eSRod Evans
229108278a5eSRod Evans } else if ((cap = CAP(lmp)) != NULL) {
229208278a5eSRod Evans /*
2293fec04708SRichard Lowe * Processing of the executable and ld.so.1 does not involve a
2294fec04708SRichard Lowe * file descriptor as exec() did all the work, so capture the
229508278a5eSRod Evans * capabilities for these cases.
229608278a5eSRod Evans */
229708278a5eSRod Evans while (cap->c_tag != CA_SUNW_NULL) {
229808278a5eSRod Evans switch (cap->c_tag) {
229908278a5eSRod Evans case CA_SUNW_HW_1:
230008278a5eSRod Evans CAPSET(lmp).sc_hw_1 = cap->c_un.c_val;
230108278a5eSRod Evans break;
230208278a5eSRod Evans case CA_SUNW_SF_1:
230308278a5eSRod Evans CAPSET(lmp).sc_sf_1 = cap->c_un.c_val;
230408278a5eSRod Evans break;
230508278a5eSRod Evans case CA_SUNW_HW_2:
230608278a5eSRod Evans CAPSET(lmp).sc_hw_2 = cap->c_un.c_val;
230708278a5eSRod Evans break;
230808278a5eSRod Evans case CA_SUNW_PLAT:
230908278a5eSRod Evans CAPSET(lmp).sc_plat = STRTAB(lmp) +
231008278a5eSRod Evans cap->c_un.c_ptr;
231108278a5eSRod Evans break;
231208278a5eSRod Evans case CA_SUNW_MACH:
231308278a5eSRod Evans CAPSET(lmp).sc_mach = STRTAB(lmp) +
231408278a5eSRod Evans cap->c_un.c_ptr;
231508278a5eSRod Evans break;
231656726c7eSRobert Mustacchi case CA_SUNW_HW_3:
231756726c7eSRobert Mustacchi CAPSET(lmp).sc_hw_3 = cap->c_un.c_val;
231856726c7eSRobert Mustacchi break;
231908278a5eSRod Evans }
232008278a5eSRod Evans cap++;
232108278a5eSRod Evans }
232208278a5eSRod Evans }
232308278a5eSRod Evans
232408278a5eSRod Evans /*
232508278a5eSRod Evans * If a capabilities chain table exists, duplicate it. The chain table
232608278a5eSRod Evans * is inspected for each initial call to a capabilities family lead
232708278a5eSRod Evans * symbol. From this chain, each family member is inspected to
232808278a5eSRod Evans * determine the 'best' family member. The chain table is then updated
232908278a5eSRod Evans * so that the best member is immediately selected for any further
233008278a5eSRod Evans * family searches.
233108278a5eSRod Evans */
233208278a5eSRod Evans if (CAPCHAIN(lmp)) {
233308278a5eSRod Evans Capchain *capchain;
233408278a5eSRod Evans
2335*7eca354dSToomas Soome if ((capchain = calloc(1, CAPCHAINSZ(lmp))) == NULL)
233608278a5eSRod Evans return (NULL);
233708278a5eSRod Evans (void) memcpy(capchain, CAPCHAIN(lmp), CAPCHAINSZ(lmp));
233808278a5eSRod Evans CAPCHAIN(lmp) = capchain;
233908278a5eSRod Evans }
234056deab07SRod Evans
23417c478bd9Sstevel@tonic-gate /*
23427c478bd9Sstevel@tonic-gate * Add the mapped object to the end of the link map list.
23437c478bd9Sstevel@tonic-gate */
23447c478bd9Sstevel@tonic-gate lm_append(lml, lmco, lmp);
234556deab07SRod Evans
234656deab07SRod Evans /*
234756deab07SRod Evans * Start the system loading in the ELF information we'll be processing.
234856deab07SRod Evans */
234956deab07SRod Evans if (REL(lmp)) {
235056deab07SRod Evans (void) madvise((void *)ADDR(lmp), (uintptr_t)REL(lmp) +
235156deab07SRod Evans (uintptr_t)RELSZ(lmp) - (uintptr_t)ADDR(lmp),
235256deab07SRod Evans MADV_WILLNEED);
235356deab07SRod Evans }
23547c478bd9Sstevel@tonic-gate return (lmp);
23557c478bd9Sstevel@tonic-gate }
23567c478bd9Sstevel@tonic-gate
23577c478bd9Sstevel@tonic-gate /*
23587c478bd9Sstevel@tonic-gate * Build full pathname of shared object from given directory name and filename.
23597c478bd9Sstevel@tonic-gate */
23607c478bd9Sstevel@tonic-gate static char *
236156deab07SRod Evans elf_get_so(const char *dir, const char *file, size_t dlen, size_t flen)
23627c478bd9Sstevel@tonic-gate {
23637c478bd9Sstevel@tonic-gate static char pname[PATH_MAX];
23647c478bd9Sstevel@tonic-gate
236556deab07SRod Evans (void) strncpy(pname, dir, dlen);
236656deab07SRod Evans pname[dlen++] = '/';
236756deab07SRod Evans (void) strncpy(&pname[dlen], file, flen + 1);
23687c478bd9Sstevel@tonic-gate return (pname);
23697c478bd9Sstevel@tonic-gate }
23707c478bd9Sstevel@tonic-gate
23717c478bd9Sstevel@tonic-gate /*
23727c478bd9Sstevel@tonic-gate * The copy relocation is recorded in a copy structure which will be applied
23737c478bd9Sstevel@tonic-gate * after all other relocations are carried out. This provides for copying data
23747c478bd9Sstevel@tonic-gate * that must be relocated itself (ie. pointers in shared objects). This
23757c478bd9Sstevel@tonic-gate * structure also provides a means of binding RTLD_GROUP dependencies to any
23767c478bd9Sstevel@tonic-gate * copy relocations that have been taken from any group members.
23777c478bd9Sstevel@tonic-gate *
23787c478bd9Sstevel@tonic-gate * If the size of the .bss area available for the copy information is not the
23797c478bd9Sstevel@tonic-gate * same as the source of the data inform the user if we're under ldd(1) control
23807c478bd9Sstevel@tonic-gate * (this checking was only established in 5.3, so by only issuing an error via
23817c478bd9Sstevel@tonic-gate * ldd(1) we maintain the standard set by previous releases).
23827c478bd9Sstevel@tonic-gate */
23837c478bd9Sstevel@tonic-gate int
23847c478bd9Sstevel@tonic-gate elf_copy_reloc(char *name, Sym *rsym, Rt_map *rlmp, void *radd, Sym *dsym,
23857c478bd9Sstevel@tonic-gate Rt_map *dlmp, const void *dadd)
23867c478bd9Sstevel@tonic-gate {
23877c478bd9Sstevel@tonic-gate Rel_copy rc;
23887c478bd9Sstevel@tonic-gate Lm_list *lml = LIST(rlmp);
23897c478bd9Sstevel@tonic-gate
23907c478bd9Sstevel@tonic-gate rc.r_name = name;
23917c478bd9Sstevel@tonic-gate rc.r_rsym = rsym; /* the new reference symbol and its */
23927c478bd9Sstevel@tonic-gate rc.r_rlmp = rlmp; /* associated link-map */
23937c478bd9Sstevel@tonic-gate rc.r_dlmp = dlmp; /* the defining link-map */
23947c478bd9Sstevel@tonic-gate rc.r_dsym = dsym; /* the original definition */
23957c478bd9Sstevel@tonic-gate rc.r_radd = radd;
23967c478bd9Sstevel@tonic-gate rc.r_dadd = dadd;
23977c478bd9Sstevel@tonic-gate
23987c478bd9Sstevel@tonic-gate if (rsym->st_size > dsym->st_size)
23997c478bd9Sstevel@tonic-gate rc.r_size = (size_t)dsym->st_size;
24007c478bd9Sstevel@tonic-gate else
24017c478bd9Sstevel@tonic-gate rc.r_size = (size_t)rsym->st_size;
24027c478bd9Sstevel@tonic-gate
2403cce0e03bSab if (alist_append(©_R(dlmp), &rc, sizeof (Rel_copy),
240456deab07SRod Evans AL_CNT_COPYREL) == NULL) {
24057c478bd9Sstevel@tonic-gate if (!(lml->lm_flags & LML_FLG_TRC_WARN))
24067c478bd9Sstevel@tonic-gate return (0);
24077c478bd9Sstevel@tonic-gate else
24087c478bd9Sstevel@tonic-gate return (1);
24097c478bd9Sstevel@tonic-gate }
24107c478bd9Sstevel@tonic-gate if (!(FLAGS1(dlmp) & FL1_RT_COPYTOOK)) {
2411cce0e03bSab if (aplist_append(©_S(rlmp), dlmp,
2412cce0e03bSab AL_CNT_COPYREL) == NULL) {
24137c478bd9Sstevel@tonic-gate if (!(lml->lm_flags & LML_FLG_TRC_WARN))
24147c478bd9Sstevel@tonic-gate return (0);
24157c478bd9Sstevel@tonic-gate else
24167c478bd9Sstevel@tonic-gate return (1);
24177c478bd9Sstevel@tonic-gate }
24187c478bd9Sstevel@tonic-gate FLAGS1(dlmp) |= FL1_RT_COPYTOOK;
24197c478bd9Sstevel@tonic-gate }
24207c478bd9Sstevel@tonic-gate
24217c478bd9Sstevel@tonic-gate /*
24227c478bd9Sstevel@tonic-gate * If we are tracing (ldd), warn the user if
24237c478bd9Sstevel@tonic-gate * 1) the size from the reference symbol differs from the
24247c478bd9Sstevel@tonic-gate * copy definition. We can only copy as much data as the
24257c478bd9Sstevel@tonic-gate * reference (dynamic executables) entry allows.
24267c478bd9Sstevel@tonic-gate * 2) the copy definition has STV_PROTECTED visibility.
24277c478bd9Sstevel@tonic-gate */
24287c478bd9Sstevel@tonic-gate if (lml->lm_flags & LML_FLG_TRC_WARN) {
24297c478bd9Sstevel@tonic-gate if (rsym->st_size != dsym->st_size) {
24307c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_CPY_SIZDIF),
24315aefb655Srie _conv_reloc_type(M_R_COPY), demangle(name),
24327c478bd9Sstevel@tonic-gate NAME(rlmp), EC_XWORD(rsym->st_size),
24337c478bd9Sstevel@tonic-gate NAME(dlmp), EC_XWORD(dsym->st_size));
24347c478bd9Sstevel@tonic-gate if (rsym->st_size > dsym->st_size)
24357c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_CPY_INSDATA),
24367c478bd9Sstevel@tonic-gate NAME(dlmp));
24377c478bd9Sstevel@tonic-gate else
24387c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_CPY_DATRUNC),
24397c478bd9Sstevel@tonic-gate NAME(rlmp));
24407c478bd9Sstevel@tonic-gate }
24417c478bd9Sstevel@tonic-gate
24427c478bd9Sstevel@tonic-gate if (ELF_ST_VISIBILITY(dsym->st_other) == STV_PROTECTED) {
24437c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_CPY_PROT),
24445aefb655Srie _conv_reloc_type(M_R_COPY), demangle(name),
2445a953e2b1Srie NAME(dlmp));
24467c478bd9Sstevel@tonic-gate }
24477c478bd9Sstevel@tonic-gate }
24487c478bd9Sstevel@tonic-gate
24495aefb655Srie DBG_CALL(Dbg_reloc_apply_val(lml, ELF_DBG_RTLD, (Xword)radd,
24505aefb655Srie (Xword)rc.r_size));
24517c478bd9Sstevel@tonic-gate return (1);
24527c478bd9Sstevel@tonic-gate }
24537c478bd9Sstevel@tonic-gate
24547c478bd9Sstevel@tonic-gate /*
24557c478bd9Sstevel@tonic-gate * Determine the symbol location of an address within a link-map. Look for
24567c478bd9Sstevel@tonic-gate * the nearest symbol (whose value is less than or equal to the required
24577c478bd9Sstevel@tonic-gate * address). This is the object specific part of dladdr().
24587c478bd9Sstevel@tonic-gate */
24597c478bd9Sstevel@tonic-gate static void
24607c478bd9Sstevel@tonic-gate elf_dladdr(ulong_t addr, Rt_map *lmp, Dl_info *dlip, void **info, int flags)
24617c478bd9Sstevel@tonic-gate {
24627c478bd9Sstevel@tonic-gate ulong_t ndx, cnt, base, _value;
24636221fe92Sab Sym *sym, *_sym = NULL;
24647c478bd9Sstevel@tonic-gate const char *str;
24655343e1b3Sab int _flags;
2466d579eb63Sab uint_t *dynaddr_ndx;
2467d579eb63Sab uint_t dynaddr_n = 0;
2468d579eb63Sab ulong_t value;
24697c478bd9Sstevel@tonic-gate
24707c478bd9Sstevel@tonic-gate /*
24719039eeafSab * If SUNWSYMTAB() is non-NULL, then it sees a special version of
24729039eeafSab * the dynsym that starts with any local function symbols that exist in
24739039eeafSab * the library and then moves to the data held in SYMTAB(). In this
24749039eeafSab * case, SUNWSYMSZ tells us how long the symbol table is. The
24759039eeafSab * availability of local function symbols will enhance the results
24769039eeafSab * we can provide.
24779039eeafSab *
2478d579eb63Sab * If SUNWSYMTAB() is non-NULL, then there might also be a
2479d579eb63Sab * SUNWSYMSORT() vector associated with it. SUNWSYMSORT() contains
2480d579eb63Sab * an array of indices into SUNWSYMTAB, sorted by increasing
2481d579eb63Sab * address. We can use this to do an O(log N) search instead of a
2482d579eb63Sab * brute force search.
2483d579eb63Sab *
24849039eeafSab * If SUNWSYMTAB() is NULL, then SYMTAB() references a dynsym that
24859039eeafSab * contains only global symbols. In that case, the length of
24869039eeafSab * the symbol table comes from the nchain field of the related
24879039eeafSab * symbol lookup hash table.
24887c478bd9Sstevel@tonic-gate */
24897c478bd9Sstevel@tonic-gate str = STRTAB(lmp);
249067d74cc3SToomas Soome if (SUNWSYMSZ(lmp) == 0) {
24919039eeafSab sym = SYMTAB(lmp);
24929039eeafSab /*
24939039eeafSab * If we don't have a .hash table there are no symbols
24949039eeafSab * to look at.
24959039eeafSab */
2496481bba9eSRod Evans if (HASH(lmp) == NULL)
24979039eeafSab return;
24989039eeafSab cnt = HASH(lmp)[1];
24999039eeafSab } else {
25009039eeafSab sym = SUNWSYMTAB(lmp);
25019039eeafSab cnt = SUNWSYMSZ(lmp) / SYMENT(lmp);
2502d579eb63Sab dynaddr_ndx = SUNWSYMSORT(lmp);
2503d579eb63Sab if (dynaddr_ndx != NULL)
2504d579eb63Sab dynaddr_n = SUNWSYMSORTSZ(lmp) / SUNWSORTENT(lmp);
25059039eeafSab }
25067c478bd9Sstevel@tonic-gate
25077c478bd9Sstevel@tonic-gate if (FLAGS(lmp) & FLG_RT_FIXED)
25087c478bd9Sstevel@tonic-gate base = 0;
25097c478bd9Sstevel@tonic-gate else
25107c478bd9Sstevel@tonic-gate base = ADDR(lmp);
25117c478bd9Sstevel@tonic-gate
2512d579eb63Sab if (dynaddr_n > 0) { /* Binary search */
2513d579eb63Sab long low = 0, low_bnd;
2514d579eb63Sab long high = dynaddr_n - 1, high_bnd;
2515d579eb63Sab long mid;
2516d579eb63Sab Sym *mid_sym;
25177c478bd9Sstevel@tonic-gate
25189039eeafSab /*
2519d579eb63Sab * Note that SUNWSYMSORT only contains symbols types that
2520d579eb63Sab * supply memory addresses, so there's no need to check and
2521d579eb63Sab * filter out any other types.
25229039eeafSab */
2523d579eb63Sab low_bnd = low;
2524d579eb63Sab high_bnd = high;
2525d579eb63Sab while (low <= high) {
2526d579eb63Sab mid = (low + high) / 2;
2527d579eb63Sab mid_sym = &sym[dynaddr_ndx[mid]];
2528d579eb63Sab value = mid_sym->st_value + base;
2529d579eb63Sab if (addr < value) {
2530d579eb63Sab if ((sym[dynaddr_ndx[high]].st_value + base) >=
2531d579eb63Sab addr)
2532d579eb63Sab high_bnd = high;
2533d579eb63Sab high = mid - 1;
2534d579eb63Sab } else if (addr > value) {
2535d579eb63Sab if ((sym[dynaddr_ndx[low]].st_value + base) <=
2536d579eb63Sab addr)
2537d579eb63Sab low_bnd = low;
2538d579eb63Sab low = mid + 1;
2539d579eb63Sab } else {
2540d579eb63Sab _sym = mid_sym;
2541d579eb63Sab _value = value;
2542d579eb63Sab break;
2543d579eb63Sab }
2544d579eb63Sab }
2545d579eb63Sab /*
2546d579eb63Sab * If the above didn't find it exactly, then we must
2547d579eb63Sab * return the closest symbol with a value that doesn't
2548d579eb63Sab * exceed the one we are looking for. If that symbol exists,
2549d579eb63Sab * it will lie in the range bounded by low_bnd and
2550d579eb63Sab * high_bnd. This is a linear search, but a short one.
2551d579eb63Sab */
2552d579eb63Sab if (_sym == NULL) {
2553d579eb63Sab for (mid = low_bnd; mid <= high_bnd; mid++) {
2554d579eb63Sab mid_sym = &sym[dynaddr_ndx[mid]];
2555d579eb63Sab value = mid_sym->st_value + base;
2556d579eb63Sab if (addr >= value) {
2557d579eb63Sab _sym = mid_sym;
2558d579eb63Sab _value = value;
2559d579eb63Sab } else {
2560d579eb63Sab break;
2561d579eb63Sab }
2562d579eb63Sab }
2563d579eb63Sab }
2564d579eb63Sab } else { /* Linear search */
2565d579eb63Sab for (_value = 0, sym++, ndx = 1; ndx < cnt; ndx++, sym++) {
2566d579eb63Sab /*
2567d579eb63Sab * Skip expected symbol types that are not functions
2568d579eb63Sab * or data:
2569d579eb63Sab * - A symbol table starts with an undefined symbol
2570d579eb63Sab * in slot 0. If we are using SUNWSYMTAB(),
2571d579eb63Sab * there will be a second undefined symbol
2572d579eb63Sab * right before the globals.
2573d579eb63Sab * - The local part of SUNWSYMTAB() contains a
2574d579eb63Sab * series of function symbols. Each section
2575d579eb63Sab * starts with an initial STT_FILE symbol.
2576d579eb63Sab */
2577d579eb63Sab if ((sym->st_shndx == SHN_UNDEF) ||
2578d579eb63Sab (ELF_ST_TYPE(sym->st_info) == STT_FILE))
2579d579eb63Sab continue;
25807c478bd9Sstevel@tonic-gate
2581d579eb63Sab value = sym->st_value + base;
2582d579eb63Sab if (value > addr)
2583d579eb63Sab continue;
2584d579eb63Sab if (value < _value)
2585d579eb63Sab continue;
25867c478bd9Sstevel@tonic-gate
2587d579eb63Sab _sym = sym;
2588d579eb63Sab _value = value;
25897c478bd9Sstevel@tonic-gate
2590d579eb63Sab /*
2591d579eb63Sab * Note, because we accept local and global symbols
2592d579eb63Sab * we could find a section symbol that matches the
2593d579eb63Sab * associated address, which means that the symbol
2594d579eb63Sab * name will be null. In this case continue the
2595d579eb63Sab * search in case we can find a global symbol of
2596d579eb63Sab * the same value.
2597d579eb63Sab */
2598d579eb63Sab if ((value == addr) &&
2599d579eb63Sab (ELF_ST_TYPE(sym->st_info) != STT_SECTION))
2600d579eb63Sab break;
2601d579eb63Sab }
26027c478bd9Sstevel@tonic-gate }
26037c478bd9Sstevel@tonic-gate
26045343e1b3Sab _flags = flags & RTLD_DL_MASK;
26057c478bd9Sstevel@tonic-gate if (_sym) {
26067c478bd9Sstevel@tonic-gate if (_flags == RTLD_DL_SYMENT)
26077c478bd9Sstevel@tonic-gate *info = (void *)_sym;
26087c478bd9Sstevel@tonic-gate else if (_flags == RTLD_DL_LINKMAP)
26097c478bd9Sstevel@tonic-gate *info = (void *)lmp;
26107c478bd9Sstevel@tonic-gate
26117c478bd9Sstevel@tonic-gate dlip->dli_sname = str + _sym->st_name;
26127c478bd9Sstevel@tonic-gate dlip->dli_saddr = (void *)_value;
26135343e1b3Sab } else {
26145343e1b3Sab /*
26155343e1b3Sab * addr lies between the beginning of the mapped segment and
26165343e1b3Sab * the first global symbol. We have no symbol to return
26175343e1b3Sab * and the caller requires one. We use _START_, the base
26185343e1b3Sab * address of the mapping.
26195343e1b3Sab */
26205343e1b3Sab
26215343e1b3Sab if (_flags == RTLD_DL_SYMENT) {
26225343e1b3Sab /*
26235343e1b3Sab * An actual symbol struct is needed, so we
26245343e1b3Sab * construct one for _START_. To do this in a
26255343e1b3Sab * fully accurate way requires a different symbol
26265343e1b3Sab * for each mapped segment. This requires the
26275343e1b3Sab * use of dynamic memory and a mutex. That's too much
26285343e1b3Sab * plumbing for a fringe case of limited importance.
26295343e1b3Sab *
26305343e1b3Sab * Fortunately, we can simplify:
26315343e1b3Sab * - Only the st_size and st_info fields are useful
26325343e1b3Sab * outside of the linker internals. The others
26335343e1b3Sab * reference things that outside code cannot see,
26345343e1b3Sab * and can be set to 0.
26355343e1b3Sab * - It's just a label and there is no size
26365343e1b3Sab * to report. So, the size should be 0.
26375343e1b3Sab * This means that only st_info needs a non-zero
26385343e1b3Sab * (constant) value. A static struct will suffice.
26395343e1b3Sab * It must be const (readonly) so the caller can't
26405343e1b3Sab * change its meaning for subsequent callers.
26415343e1b3Sab */
26425343e1b3Sab static const Sym fsym = { 0, 0, 0,
264337ffaf83SRod Evans ELF_ST_INFO(STB_LOCAL, STT_OBJECT) };
26445343e1b3Sab *info = (void *) &fsym;
26455343e1b3Sab }
26465343e1b3Sab
26475343e1b3Sab dlip->dli_sname = MSG_ORIG(MSG_SYM_START);
26485343e1b3Sab dlip->dli_saddr = (void *) ADDR(lmp);
26497c478bd9Sstevel@tonic-gate }
26507c478bd9Sstevel@tonic-gate }
26517c478bd9Sstevel@tonic-gate
26527c478bd9Sstevel@tonic-gate /*
265375e7992aSrie * This routine is called as a last fall-back to search for a symbol from a
26542017c965SRod Evans * standard relocation or dlsym(). To maintain lazy loadings goal of reducing
26552017c965SRod Evans * the number of objects mapped, any symbol search is first carried out using
26562017c965SRod Evans * the objects that already exist in the process (either on a link-map list or
26572017c965SRod Evans * handle). If a symbol can't be found, and lazy dependencies are still
26582017c965SRod Evans * pending, this routine loads the dependencies in an attempt to locate the
26592017c965SRod Evans * symbol.
26607c478bd9Sstevel@tonic-gate */
266108278a5eSRod Evans int
266208278a5eSRod Evans elf_lazy_find_sym(Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl)
26637c478bd9Sstevel@tonic-gate {
26642017c965SRod Evans static APlist *alist = NULL;
26652017c965SRod Evans Aliste idx1;
26662017c965SRod Evans Rt_map *lmp1, *lmp = slp->sl_imap, *clmp = slp->sl_cmap;
26677c478bd9Sstevel@tonic-gate const char *name = slp->sl_name;
26682017c965SRod Evans Slookup sl1 = *slp;
26692017c965SRod Evans Lm_list *lml;
26702017c965SRod Evans Lm_cntl *lmc;
26712017c965SRod Evans
26722017c965SRod Evans /*
26732017c965SRod Evans * It's quite possible we've been here before to process objects,
26742017c965SRod Evans * therefore reinitialize our dynamic list.
26752017c965SRod Evans */
26762017c965SRod Evans if (alist)
26772017c965SRod Evans aplist_reset(alist);
26782017c965SRod Evans
26792017c965SRod Evans /*
26802017c965SRod Evans * Discard any relocation index from further symbol searches. This
26812017c965SRod Evans * index has already been used to trigger any necessary lazy-loads,
26822017c965SRod Evans * and it might be because one of these lazy loads has failed that
26832017c965SRod Evans * we're performing this fallback. By removing the relocation index
26842017c965SRod Evans * we don't try and perform the same failed lazy loading activity again.
26852017c965SRod Evans */
26862017c965SRod Evans sl1.sl_rsymndx = 0;
26872017c965SRod Evans
26882017c965SRod Evans /*
26892017c965SRod Evans * Determine the callers link-map list so that we can monitor whether
26902017c965SRod Evans * new objects have been added.
26912017c965SRod Evans */
26922017c965SRod Evans lml = LIST(clmp);
26932017c965SRod Evans lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, CNTL(clmp));
26947c478bd9Sstevel@tonic-gate
269575e7992aSrie /*
269675e7992aSrie * Generate a local list of new objects to process. This list can grow
269775e7992aSrie * as each object supplies its own lazy dependencies.
269875e7992aSrie */
2699cce0e03bSab if (aplist_append(&alist, lmp, AL_CNT_LAZYFIND) == NULL)
270067d74cc3SToomas Soome return (0);
27017c478bd9Sstevel@tonic-gate
27022017c965SRod Evans for (APLIST_TRAVERSE(alist, idx1, lmp1)) {
2703f441771bSRod Evans uint_t dynndx;
270475e7992aSrie Dyninfo *dip, *pdip;
27057c478bd9Sstevel@tonic-gate
270675e7992aSrie /*
270775e7992aSrie * Loop through the lazy DT_NEEDED entries examining each object
270875e7992aSrie * for the required symbol. If the symbol is not found, the
270975e7992aSrie * object is in turn added to the local alist, so that the
271075e7992aSrie * objects lazy DT_NEEDED entries can be examined.
27117c478bd9Sstevel@tonic-gate */
2712cce0e03bSab lmp = lmp1;
2713f441771bSRod Evans for (dynndx = 0, dip = DYNINFO(lmp), pdip = NULL;
2714f441771bSRod Evans !(dip->di_flags & FLG_DI_IGNORE); dynndx++, pdip = dip++) {
27152017c965SRod Evans Grp_hdl *ghp;
27162017c965SRod Evans Grp_desc *gdp;
27172017c965SRod Evans Rt_map *nlmp, *llmp;
27182017c965SRod Evans Slookup sl2;
271908278a5eSRod Evans Sresult sr;
27202017c965SRod Evans Aliste idx2;
27217c478bd9Sstevel@tonic-gate
272275e7992aSrie if (((dip->di_flags & FLG_DI_LAZY) == 0) ||
27237c478bd9Sstevel@tonic-gate dip->di_info)
27247c478bd9Sstevel@tonic-gate continue;
27257c478bd9Sstevel@tonic-gate
27267c478bd9Sstevel@tonic-gate /*
272775e7992aSrie * If this object has already failed to lazy load, and
272875e7992aSrie * we're still processing the same runtime linker
272975e7992aSrie * operation that produced the failure, don't bother
273075e7992aSrie * to try and load the object again.
273175e7992aSrie */
273275e7992aSrie if ((dip->di_flags & FLG_DI_LAZYFAIL) && pdip &&
273375e7992aSrie (pdip->di_flags & FLG_DI_POSFLAG1)) {
273475e7992aSrie if (pdip->di_info == (void *)ld_entry_cnt)
273575e7992aSrie continue;
273675e7992aSrie
273775e7992aSrie dip->di_flags &= ~FLG_DI_LAZYFAIL;
273875e7992aSrie pdip->di_info = NULL;
273975e7992aSrie }
274075e7992aSrie
27412017c965SRod Evans /*
27422017c965SRod Evans * Determine the last link-map presently on the callers
27432017c965SRod Evans * link-map control list.
27442017c965SRod Evans */
27452017c965SRod Evans llmp = lmc->lc_tail;
27462017c965SRod Evans
274775e7992aSrie /*
274875e7992aSrie * Try loading this lazy dependency. If the object
274975e7992aSrie * can't be loaded, consider this non-fatal and continue
275075e7992aSrie * the search. Lazy loaded dependencies need not exist
275175e7992aSrie * and their loading should only turn out to be fatal
275275e7992aSrie * if they are required to satisfy a relocation.
27537c478bd9Sstevel@tonic-gate *
27542017c965SRod Evans * A successful lazy load can mean one of two things:
27552017c965SRod Evans *
27562017c965SRod Evans * - new objects have been loaded, in which case the
275767d74cc3SToomas Soome * objects will have been analyzed, relocated, and
275867d74cc3SToomas Soome * finally moved to the callers control list.
27592017c965SRod Evans * - the objects are already loaded, and this lazy
27602017c965SRod Evans * load has simply associated the referenced object
27612017c965SRod Evans * with it's lazy dependencies.
27622017c965SRod Evans *
27632017c965SRod Evans * If new objects are loaded, look in these objects
27642017c965SRod Evans * first. Note, a new object can be the object being
27652017c965SRod Evans * referenced by this lazy load, however we can also
27662017c965SRod Evans * descend into multiple lazy loads as we relocate this
27672017c965SRod Evans * reference.
27682017c965SRod Evans *
27692017c965SRod Evans * If the symbol hasn't been found, use the referenced
27702017c965SRod Evans * objects handle, as it might have dependencies on
2771e0e63816SRod Evans * objects that are already loaded. Note that existing
2772e0e63816SRod Evans * objects might have already been searched and skipped
2773e0e63816SRod Evans * as non-available to this caller. However, a lazy
2774e0e63816SRod Evans * load might have caused the promotion of modes, or
2775e0e63816SRod Evans * added this object to the family of the caller. In
2776e0e63816SRod Evans * either case, the handle associated with the object
2777e0e63816SRod Evans * is then used to carry out the symbol search.
27787c478bd9Sstevel@tonic-gate */
2779f441771bSRod Evans if ((nlmp = elf_lazy_load(lmp, &sl1, dynndx, name,
27802017c965SRod Evans FLG_RT_PRIHDL, &ghp, in_nfavl)) == NULL)
27817c478bd9Sstevel@tonic-gate continue;
27827c478bd9Sstevel@tonic-gate
27832017c965SRod Evans if (NEXT_RT_MAP(llmp)) {
27842017c965SRod Evans /*
27852017c965SRod Evans * Look in any new objects.
27862017c965SRod Evans */
27872017c965SRod Evans sl1.sl_imap = NEXT_RT_MAP(llmp);
27882017c965SRod Evans sl1.sl_flags &= ~LKUP_STDRELOC;
27892017c965SRod Evans
279008278a5eSRod Evans /*
279108278a5eSRod Evans * Initialize a local symbol result descriptor,
279208278a5eSRod Evans * using the original symbol name.
279308278a5eSRod Evans */
279408278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name);
279508278a5eSRod Evans
279608278a5eSRod Evans if (lookup_sym(&sl1, &sr, binfo, in_nfavl)) {
279708278a5eSRod Evans *srp = sr;
279808278a5eSRod Evans return (1);
279908278a5eSRod Evans }
28002017c965SRod Evans }
28012017c965SRod Evans
28027c478bd9Sstevel@tonic-gate /*
2803e0e63816SRod Evans * Use the objects handle to inspect the family of
2804e0e63816SRod Evans * objects associated with the handle. Note, there's
28052017c965SRod Evans * a possibility of overlap with the above search,
28062017c965SRod Evans * should a lazy load bring in new objects and
28072017c965SRod Evans * reference existing objects.
28087c478bd9Sstevel@tonic-gate */
28092017c965SRod Evans sl2 = sl1;
28102017c965SRod Evans for (ALIST_TRAVERSE(ghp->gh_depends, idx2, gdp)) {
2811e0e63816SRod Evans if ((gdp->gd_depend != NEXT_RT_MAP(llmp)) &&
28122017c965SRod Evans (gdp->gd_flags & GPD_DLSYM)) {
28132017c965SRod Evans
28142017c965SRod Evans sl2.sl_imap = gdp->gd_depend;
28152017c965SRod Evans sl2.sl_flags |= LKUP_FIRST;
28162017c965SRod Evans
281708278a5eSRod Evans /*
281808278a5eSRod Evans * Initialize a local symbol result
281908278a5eSRod Evans * descriptor, using the original
282008278a5eSRod Evans * symbol name.
282108278a5eSRod Evans */
282208278a5eSRod Evans SRESULT_INIT(sr, slp->sl_name);
282308278a5eSRod Evans
282408278a5eSRod Evans if (lookup_sym(&sl2, &sr, binfo,
282508278a5eSRod Evans in_nfavl)) {
282608278a5eSRod Evans *srp = sr;
282708278a5eSRod Evans return (1);
282808278a5eSRod Evans }
28292017c965SRod Evans }
28302017c965SRod Evans }
28312017c965SRod Evans
28327c478bd9Sstevel@tonic-gate /*
28337c478bd9Sstevel@tonic-gate * Some dlsym() operations are already traversing a
28347c478bd9Sstevel@tonic-gate * link-map (dlopen(0)), and thus there's no need to
28352017c965SRod Evans * save them on the dynamic dependency list.
28367c478bd9Sstevel@tonic-gate */
28372017c965SRod Evans if (slp->sl_flags & LKUP_NODESCENT)
28382017c965SRod Evans continue;
28392017c965SRod Evans
284067d74cc3SToomas Soome if (aplist_test(&alist, nlmp, AL_CNT_LAZYFIND) == 0)
284108278a5eSRod Evans return (0);
28427c478bd9Sstevel@tonic-gate }
28437c478bd9Sstevel@tonic-gate }
28447c478bd9Sstevel@tonic-gate
284508278a5eSRod Evans return (0);
28467c478bd9Sstevel@tonic-gate }
28477c478bd9Sstevel@tonic-gate
28487c478bd9Sstevel@tonic-gate /*
28497c478bd9Sstevel@tonic-gate * Warning message for bad r_offset.
28507c478bd9Sstevel@tonic-gate */
28517c478bd9Sstevel@tonic-gate void
28527c478bd9Sstevel@tonic-gate elf_reloc_bad(Rt_map *lmp, void *rel, uchar_t rtype, ulong_t roffset,
28537c478bd9Sstevel@tonic-gate ulong_t rsymndx)
28547c478bd9Sstevel@tonic-gate {
285537ffaf83SRod Evans const char *name = NULL;
28565aefb655Srie Lm_list *lml = LIST(lmp);
28577c478bd9Sstevel@tonic-gate int trace;
28587c478bd9Sstevel@tonic-gate
28595aefb655Srie if ((lml->lm_flags & LML_FLG_TRC_ENABLE) &&
28607c478bd9Sstevel@tonic-gate (((rtld_flags & RT_FL_SILENCERR) == 0) ||
28615aefb655Srie (lml->lm_flags & LML_FLG_TRC_VERBOSE)))
28627c478bd9Sstevel@tonic-gate trace = 1;
28637c478bd9Sstevel@tonic-gate else
28647c478bd9Sstevel@tonic-gate trace = 0;
28657c478bd9Sstevel@tonic-gate
28665aefb655Srie if ((trace == 0) && (DBG_ENABLED == 0))
28677c478bd9Sstevel@tonic-gate return;
28687c478bd9Sstevel@tonic-gate
28697c478bd9Sstevel@tonic-gate if (rsymndx) {
28707c478bd9Sstevel@tonic-gate Sym *symref = (Sym *)((ulong_t)SYMTAB(lmp) +
2871a953e2b1Srie (rsymndx * SYMENT(lmp)));
28727c478bd9Sstevel@tonic-gate
28737c478bd9Sstevel@tonic-gate if (ELF_ST_BIND(symref->st_info) != STB_LOCAL)
28747c478bd9Sstevel@tonic-gate name = (char *)(STRTAB(lmp) + symref->st_name);
28757c478bd9Sstevel@tonic-gate }
28767c478bd9Sstevel@tonic-gate
2877481bba9eSRod Evans if (name == NULL)
287856deab07SRod Evans name = MSG_INTL(MSG_STR_UNKNOWN);
28797c478bd9Sstevel@tonic-gate
28807c478bd9Sstevel@tonic-gate if (trace) {
28817c478bd9Sstevel@tonic-gate const char *rstr;
28827c478bd9Sstevel@tonic-gate
28835aefb655Srie rstr = _conv_reloc_type((uint_t)rtype);
28847c478bd9Sstevel@tonic-gate (void) printf(MSG_INTL(MSG_LDD_REL_ERR1), rstr, name,
28857c478bd9Sstevel@tonic-gate EC_ADDR(roffset));
28867c478bd9Sstevel@tonic-gate return;
28877c478bd9Sstevel@tonic-gate }
28887c478bd9Sstevel@tonic-gate
28895aefb655Srie Dbg_reloc_error(lml, ELF_DBG_RTLD, M_MACH, M_REL_SHT_TYPE, rel, name);
28907c478bd9Sstevel@tonic-gate }
2891d326b23bSrie
2892d326b23bSrie /*
2893d326b23bSrie * Resolve a static TLS relocation.
2894d326b23bSrie */
2895d326b23bSrie long
2896d326b23bSrie elf_static_tls(Rt_map *lmp, Sym *sym, void *rel, uchar_t rtype, char *name,
2897d326b23bSrie ulong_t roffset, long value)
2898d326b23bSrie {
2899d326b23bSrie Lm_list *lml = LIST(lmp);
2900d326b23bSrie
2901d326b23bSrie /*
2902d326b23bSrie * Relocations against a static TLS block have limited support once
2903d326b23bSrie * process initialization has completed. Any error condition should be
2904d326b23bSrie * discovered by testing for DF_STATIC_TLS as part of loading an object,
2905d326b23bSrie * however individual relocations are tested in case the dynamic flag
2906d326b23bSrie * had not been set when this object was built.
2907d326b23bSrie */
2908481bba9eSRod Evans if (PTTLS(lmp) == NULL) {
2909d326b23bSrie DBG_CALL(Dbg_reloc_in(lml, ELF_DBG_RTLD, M_MACH,
2910e23c41c9SAli Bahrami M_REL_SHT_TYPE, rel, NULL, 0, name));
2911d326b23bSrie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_REL_BADTLS),
2912d326b23bSrie _conv_reloc_type((uint_t)rtype), NAME(lmp),
2913d326b23bSrie name ? demangle(name) : MSG_INTL(MSG_STR_UNKNOWN));
2914d326b23bSrie return (0);
2915d326b23bSrie }
2916d326b23bSrie
2917d326b23bSrie /*
2918d326b23bSrie * If no static TLS has been set aside for this object, determine if
2919d326b23bSrie * any can be obtained. Enforce that any object using static TLS is
2920d326b23bSrie * non-deletable.
2921d326b23bSrie */
2922d326b23bSrie if (TLSSTATOFF(lmp) == 0) {
2923d326b23bSrie FLAGS1(lmp) |= FL1_RT_TLSSTAT;
2924d326b23bSrie MODE(lmp) |= RTLD_NODELETE;
2925d326b23bSrie
2926d326b23bSrie if (tls_assign(lml, lmp, PTTLS(lmp)) == 0) {
2927d326b23bSrie DBG_CALL(Dbg_reloc_in(lml, ELF_DBG_RTLD, M_MACH,
2928e23c41c9SAli Bahrami M_REL_SHT_TYPE, rel, NULL, 0, name));
2929d326b23bSrie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_REL_BADTLS),
2930d326b23bSrie _conv_reloc_type((uint_t)rtype), NAME(lmp),
2931d326b23bSrie name ? demangle(name) : MSG_INTL(MSG_STR_UNKNOWN));
2932d326b23bSrie return (0);
2933d326b23bSrie }
2934d326b23bSrie }
2935d326b23bSrie
2936d326b23bSrie /*
2937d326b23bSrie * Typically, a static TLS offset is maintained as a symbols value.
2938d326b23bSrie * For local symbols that are not apart of the dynamic symbol table,
2939d326b23bSrie * the TLS relocation points to a section symbol, and the static TLS
2940d326b23bSrie * offset was deposited in the associated GOT table. Make sure the GOT
2941d326b23bSrie * is cleared, so that the value isn't reused in do_reloc().
2942d326b23bSrie */
2943d326b23bSrie if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) {
2944d326b23bSrie if ((ELF_ST_TYPE(sym->st_info) == STT_SECTION)) {
2945d326b23bSrie value = *(long *)roffset;
2946d326b23bSrie *(long *)roffset = 0;
2947d326b23bSrie } else {
2948d326b23bSrie value = sym->st_value;
2949d326b23bSrie }
2950d326b23bSrie }
2951d326b23bSrie return (-(TLSSTATOFF(lmp) - value));
2952d326b23bSrie }
2953dae2dfb7Srie
2954dae2dfb7Srie /*
2955dae2dfb7Srie * If the symbol is not found and the reference was not to a weak symbol, report
2956dae2dfb7Srie * an error. Weak references may be unresolved.
2957dae2dfb7Srie */
2958dae2dfb7Srie int
2959dae2dfb7Srie elf_reloc_error(Rt_map *lmp, const char *name, void *rel, uint_t binfo)
2960dae2dfb7Srie {
2961dae2dfb7Srie Lm_list *lml = LIST(lmp);
2962dae2dfb7Srie
2963dae2dfb7Srie /*
2964dae2dfb7Srie * Under crle(1), relocation failures are ignored.
2965dae2dfb7Srie */
2966dae2dfb7Srie if (lml->lm_flags & LML_FLG_IGNRELERR)
2967dae2dfb7Srie return (1);
2968dae2dfb7Srie
2969dae2dfb7Srie /*
2970dae2dfb7Srie * Under ldd(1), unresolved references are reported. However, if the
2971dae2dfb7Srie * original reference is EXTERN or PARENT these references are ignored
2972dae2dfb7Srie * unless ldd's -p option is in effect.
2973dae2dfb7Srie */
2974dae2dfb7Srie if (lml->lm_flags & LML_FLG_TRC_WARN) {
2975dae2dfb7Srie if (((binfo & DBG_BINFO_REF_MSK) == 0) ||
2976dae2dfb7Srie ((lml->lm_flags & LML_FLG_TRC_NOPAREXT) != 0)) {
2977dae2dfb7Srie (void) printf(MSG_INTL(MSG_LDD_SYM_NFOUND),
2978dae2dfb7Srie demangle(name), NAME(lmp));
2979dae2dfb7Srie }
2980dae2dfb7Srie return (1);
2981dae2dfb7Srie }
2982dae2dfb7Srie
2983dae2dfb7Srie /*
2984dae2dfb7Srie * Otherwise, the unresolved references is fatal.
2985dae2dfb7Srie */
2986dae2dfb7Srie DBG_CALL(Dbg_reloc_in(lml, ELF_DBG_RTLD, M_MACH, M_REL_SHT_TYPE, rel,
2987e23c41c9SAli Bahrami NULL, 0, name));
2988dae2dfb7Srie eprintf(lml, ERR_FATAL, MSG_INTL(MSG_REL_NOSYM), NAME(lmp),
2989dae2dfb7Srie demangle(name));
2990dae2dfb7Srie
2991dae2dfb7Srie return (0);
2992dae2dfb7Srie }
2993