/* * Copyright (c) 1993 Paul Kranenburg * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Paul Kranenburg. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * $Id: rtld.c,v 1.29 1995/10/24 06:48:16 ache Exp $ */ #include #include #include #include #include #include #include #include #ifndef MAP_COPY #define MAP_COPY MAP_PRIVATE #endif #include #include #include #include #include #include #include #include #if __STDC__ #include #else #include #endif #include "ld.h" #ifndef MAP_ANON #define MAP_ANON 0 #define anon_open() do { \ if ((anon_fd = open("/dev/zero", O_RDWR, 0)) == -1) \ err("open: %s", "/dev/zero"); \ } while (0) #define anon_close() do { \ (void)close(anon_fd); \ anon_fd = -1; \ } while (0) #else #define anon_open() #define anon_close() #endif /* * Loader private data, hung off ->som_spd */ struct somap_private { int spd_version; struct so_map *spd_parent; int spd_refcount; int spd_flags; #define RTLD_MAIN 1 #define RTLD_RTLD 2 #define RTLD_DL 4 #define RTLD_INIT 8 unsigned long a_text; /* text size, if known */ unsigned long a_data; /* initialized data size */ unsigned long a_bss; /* uninitialized data size */ #ifdef SUN_COMPAT long spd_offset; /* Correction for Sun main programs */ #endif }; /* * Memorizing structure for reducing the number of calls to lookup() * during relocation. * * While relocating a given shared object, the dynamic linker maintains * a memorizing vector that is directly indexed by the symbol number * in the relocation entry. The first time a given symbol is looked * up, the memorizing vector is filled in with a pointer to the symbol * table entry, and a pointer to the so_map of the shared object in * which the symbol was defined. On subsequent uses of the same * symbol, that information is retrieved directly from the memorizing * vector, without calling lookup() again. * * A symbol that is referenced in a relocation entry is typically * referenced in many relocation entries, so this memorizing reduces * the number of calls to lookup() dramatically. The overall improvement * in the speed of dynamic linking is also dramatic -- as much as a * factor of three for programs that use many shared libaries. */ struct memoent { struct nzlist *np; /* Pointer to symbol entry */ struct so_map *src_map; /* Shared object that defined the symbol */ }; #define LM_PRIVATE(smp) ((struct somap_private *)(smp)->som_spd) #ifdef SUN_COMPAT #define LM_OFFSET(smp) (LM_PRIVATE(smp)->spd_offset) #else #define LM_OFFSET(smp) (0) #endif /* Base address for section_dispatch_table entries */ #define LM_LDBASE(smp) (smp->som_addr + LM_OFFSET(smp)) /* Start of text segment */ #define LM_TXTADDR(smp) (smp->som_addr == (caddr_t)0 ? PAGSIZ : 0) /* Start of run-time relocation_info */ #define LM_REL(smp) ((struct relocation_info *) \ (smp->som_addr + LM_OFFSET(smp) + LD_REL((smp)->som_dynamic))) /* Start of symbols */ #define LM_SYMBOL(smp, i) ((struct nzlist *) \ (smp->som_addr + LM_OFFSET(smp) + LD_SYMBOL((smp)->som_dynamic) + \ i * (LD_VERSION_NZLIST_P(smp->som_dynamic->d_version) ? \ sizeof(struct nzlist) : sizeof(struct nlist)))) /* Start of hash table */ #define LM_HASH(smp) ((struct rrs_hash *) \ ((smp)->som_addr + LM_OFFSET(smp) + LD_HASH((smp)->som_dynamic))) /* Start of strings */ #define LM_STRINGS(smp) ((char *) \ ((smp)->som_addr + LM_OFFSET(smp) + LD_STRINGS((smp)->som_dynamic))) /* End of text */ #define LM_ETEXT(smp) ((char *) \ ((smp)->som_addr + LM_TXTADDR(smp) + LD_TEXTSZ((smp)->som_dynamic))) /* Needed shared objects */ #define LM_NEED(smp) ((struct sod *) \ ((smp)->som_addr + LM_TXTADDR(smp) + LD_NEED((smp)->som_dynamic))) /* PLT is in data segment, so don't use LM_OFFSET here */ #define LM_PLT(smp) ((jmpslot_t *) \ ((smp)->som_addr + LD_PLT((smp)->som_dynamic))) /* Parent of link map */ #define LM_PARENT(smp) (LM_PRIVATE(smp)->spd_parent) char **environ; char *__progname; int errno; static uid_t uid, euid; static gid_t gid, egid; static int careful; static char __main_progname[] = "main"; static char *main_progname = __main_progname; static char us[] = "/usr/libexec/ld.so"; static int anon_fd = -1; struct so_map *link_map_head, *main_map; struct so_map **link_map_tail = &link_map_head; struct rt_symbol *rt_symbol_head; static struct memoent *symmemo; /* Nemorizing vector for symbols */ static long symmemosyms; /* Number of symbols in memo vector */ static void *__dlopen __P((char *, int)); static int __dlclose __P((void *)); static void *__dlsym __P((void *, char *)); static char *__dlerror __P((void)); static void __dlexit __P((void)); static struct ld_entry ld_entry = { __dlopen, __dlclose, __dlsym, __dlerror, __dlexit }; void xprintf __P((char *, ...)); static void load_objects __P(( struct crt_ldso *, struct _dynamic *)); static struct so_map *map_object __P((struct sod *, struct so_map *)); static int unmap_object __P((struct so_map *)); static struct so_map *load_object __P((struct sod *, struct so_map *, int, int)); static int unload_object __P((struct so_map *)); static struct so_map *alloc_link_map __P(( char *, struct sod *, struct so_map *, caddr_t, struct _dynamic *)); static inline int check_text_reloc __P(( struct relocation_info *, struct so_map *, caddr_t)); static int reloc_map __P((struct so_map *)); static void reloc_copy __P((struct so_map *)); static void init_map __P((struct so_map *, char *, int)); static void call_map __P((struct so_map *, char *)); static char *rtfindlib __P((char *, int, int, int *)); void binder_entry __P((void)); long binder __P((jmpslot_t *)); static struct nzlist *lookup __P((char *, struct so_map **, int)); static inline struct rt_symbol *lookup_rts __P((char *)); static struct rt_symbol *enter_rts __P((char *, long, int, caddr_t, long, struct so_map *)); static void *getMemory __P((size_t)); static void freeMemory __P((void *, size_t)); static void generror __P((char *, ...)); static void maphints __P((void)); static void unmaphints __P((void)); static int dl_cascade __P((struct so_map *)); static inline int strcmp (register const char *s1, register const char *s2) { while (*s1 == *s2++) if (*s1++ == 0) return (0); return (*(unsigned char *)s1 - *(unsigned char *)--s2); } #include "md-static-funcs.c" /* * Called from assembler stub that has set up crtp (passed from crt0) * and dp (our __DYNAMIC). */ int rtld(version, crtp, dp) int version; struct crt_ldso *crtp; struct _dynamic *dp; { int n; int nreloc; /* # of ld.so relocations */ struct relocation_info *reloc; struct so_debug *ddp; struct so_map *smp; /* Check version */ if (version != CRT_VERSION_BSD_2 && version != CRT_VERSION_BSD_3 && version != CRT_VERSION_SUN) return -1; /* Fixup __DYNAMIC structure */ (long)dp->d_un.d_sdt += crtp->crt_ba; /* Divide by hand to avoid possible use of library division routine */ for (nreloc = 0, n = LD_RELSZ(dp); n > 0; n -= sizeof(struct relocation_info) ) nreloc++; /* Relocate ourselves */ for (reloc = (struct relocation_info *)(LD_REL(dp) + crtp->crt_ba); nreloc; nreloc--, reloc++) { register long addr = reloc->r_address + crtp->crt_ba; md_relocate_simple(reloc, crtp->crt_ba, addr); } __progname = "ld.so"; if (version >= CRT_VERSION_BSD_3) main_progname = crtp->crt_prog; /* Setup out (private) environ variable */ environ = crtp->crt_ep; /* Get user and group identifiers */ uid = getuid(); euid = geteuid(); gid = getgid(); egid = getegid(); careful = (uid != euid) || (gid != egid); if (careful) { unsetenv("LD_LIBRARY_PATH"); unsetenv("LD_PRELOAD"); } /* Setup directory search */ add_search_path(getenv("LD_LIBRARY_PATH")); std_search_path(); anon_open(); /* Load required objects into the process address space */ load_objects(crtp, dp); /* Fill in some fields in main's __DYNAMIC structure */ crtp->crt_dp->d_entry = &ld_entry; crtp->crt_dp->d_un.d_sdt->sdt_loaded = link_map_head->som_next; /* * Determine the maximum number of run-time symbols in any of * the shared objects. */ symmemosyms = 0; for (smp = link_map_head; smp; smp = smp->som_next) { struct _dynamic *dp; size_t symsize; long numsyms; if (LM_PRIVATE(smp)->spd_flags & RTLD_RTLD) continue; dp = smp->som_dynamic; symsize = LD_VERSION_NZLIST_P(dp->d_version) ? sizeof(struct nzlist) : sizeof(struct nlist); numsyms = (LD_STRINGS(dp) - LD_SYMBOL(dp)) / symsize; if(symmemosyms < numsyms) symmemosyms = numsyms; } /* * Allocate a memorizing vector large enough to hold the maximum * number of run-time symbols. We use mmap to get the memory, so * that we can give it back to the system when we are finished * with it. */ symmemo = getMemory(symmemosyms * sizeof(struct memoent)); if(symmemo == NULL) /* Couldn't get the memory */ symmemosyms = 0; /* Relocate all loaded objects according to their RRS segments */ for (smp = link_map_head; smp; smp = smp->som_next) { if (LM_PRIVATE(smp)->spd_flags & RTLD_RTLD) continue; if (reloc_map(smp) < 0) return -1; } if(symmemosyms != 0) { /* Free the memorizing vector */ freeMemory(symmemo, symmemosyms * sizeof(struct memoent)); symmemo = NULL; symmemosyms = 0; } /* Copy any relocated initialized data. */ for (smp = link_map_head; smp; smp = smp->som_next) { if (LM_PRIVATE(smp)->spd_flags & RTLD_RTLD) continue; reloc_copy(smp); } /* Call any object initialization routines. */ for (smp = link_map_head; smp; smp = smp->som_next) { if (LM_PRIVATE(smp)->spd_flags & RTLD_RTLD) continue; init_map(smp, ".init", 0); } ddp = crtp->crt_dp->d_debug; ddp->dd_cc = rt_symbol_head; if (ddp->dd_in_debugger) { caddr_t addr = (caddr_t)((long)crtp->crt_bp & (~(PAGSIZ - 1))); /* Set breakpoint for the benefit of debuggers */ if (mprotect(addr, PAGSIZ, PROT_READ|PROT_WRITE|PROT_EXEC) == -1) { err(1, "Cannot set breakpoint (%s)", main_progname); } md_set_breakpoint((long)crtp->crt_bp, (long *)&ddp->dd_bpt_shadow); if (mprotect(addr, PAGSIZ, PROT_READ|PROT_EXEC) == -1) { err(1, "Cannot re-protect breakpoint (%s)", main_progname); } ddp->dd_bpt_addr = crtp->crt_bp; if (link_map_head) ddp->dd_sym_loaded = 1; } /* Close the hints file */ unmaphints(); /* Close our file descriptor */ (void)close(crtp->crt_ldfd); anon_close(); return LDSO_VERSION_HAS_DLEXIT; } static void load_objects(crtp, dp) struct crt_ldso *crtp; struct _dynamic *dp; { struct so_map *smp; int tracing = (int)getenv("LD_TRACE_LOADED_OBJECTS"); /* Handle LD_PRELOAD's here */ /* Make an entry for the main program */ smp = alloc_link_map(main_progname, (struct sod *)0, (struct so_map *)0, (caddr_t)0, crtp->crt_dp); LM_PRIVATE(smp)->spd_refcount++; LM_PRIVATE(smp)->spd_flags |= RTLD_MAIN; /* Make an entry for ourselves */ smp = alloc_link_map(us, (struct sod *)0, (struct so_map *)0, (caddr_t)crtp->crt_ba, dp); LM_PRIVATE(smp)->spd_refcount++; LM_PRIVATE(smp)->spd_flags |= RTLD_RTLD; for (smp = link_map_head; smp; smp = smp->som_next) { struct sod *sodp; long next = 0; if (LM_PRIVATE(smp)->spd_flags & RTLD_RTLD) continue; if (smp->som_dynamic) next = LD_NEED(smp->som_dynamic); while (next) { struct so_map *newmap; sodp = (struct sod *)(LM_LDBASE(smp) + next); if ((newmap = map_object(sodp, smp)) == NULL) { if (!tracing) { errx(1, "%s: %s", main_progname, __dlerror()); } newmap = alloc_link_map(NULL, sodp, smp, 0, 0); } LM_PRIVATE(newmap)->spd_refcount++; next = sodp->sod_next; } } if (! tracing) return; for (smp = link_map_head; smp; smp = smp->som_next) { struct sod *sodp; char *name, *path; if ((sodp = smp->som_sod) == NULL) continue; name = sodp->sod_name + LM_LDBASE(LM_PARENT(smp)); if ((path = smp->som_path) == NULL) path = "not found"; if (sodp->sod_library) printf("\t-l%s.%d => %s (%p)\n", name, sodp->sod_major, path, smp->som_addr); else printf("\t%s => %s (%p)\n", name, path, smp->som_addr); } exit(0); } /* * Allocate a new link map for shared object NAME loaded at ADDR as a * result of the presence of link object LOP in the link map PARENT. */ static struct so_map * alloc_link_map(path, sodp, parent, addr, dp) char *path; struct sod *sodp; struct so_map *parent; caddr_t addr; struct _dynamic *dp; { struct so_map *smp; struct somap_private *smpp; size_t smp_size; /* * Allocate so_map and private area with a single malloc. Round * up the size of so_map so the private area is aligned. */ smp_size = ((((sizeof(struct so_map)) + sizeof (void *) - 1) / sizeof (void *)) * sizeof (void *)); smp = (struct so_map *)xmalloc(smp_size + sizeof (struct somap_private)); smpp = (struct somap_private *) (((caddr_t) smp) + smp_size); smp->som_next = NULL; *link_map_tail = smp; link_map_tail = &smp->som_next; smp->som_addr = addr; if (path == NULL) smp->som_path = NULL; else smp->som_path = strdup(path); smp->som_sod = sodp; smp->som_dynamic = dp; smp->som_spd = (caddr_t)smpp; /*XXX*/ if (addr == 0) main_map = smp; smpp->spd_refcount = 0; smpp->spd_flags = 0; smpp->spd_parent = parent; smpp->a_text = 0; smpp->a_data = 0; smpp->a_bss = 0; #ifdef SUN_COMPAT smpp->spd_offset = (addr==0 && dp && dp->d_version==LD_VERSION_SUN) ? PAGSIZ : 0; #endif return smp; } static struct so_map * find_object(sodp, smp) struct sod *sodp; struct so_map *smp; { char *path, *name = (char *)(sodp->sod_name + LM_LDBASE(smp)); int usehints = 0; struct so_map *p; if (sodp->sod_library) { usehints = 1; again: path = rtfindlib(name, sodp->sod_major, sodp->sod_minor, &usehints); if (path == NULL) { generror ("Can't find shared library \"%s\"", name); return NULL; } } else { if (careful && *name != '/') { generror ("Shared library path must start with \"/\" for \"%s\"", name); return NULL; } path = name; } /* Check if already loaded */ for (p = link_map_head; p; p = p->som_next) if (p->som_path && strcmp(p->som_path, path) == 0) break; return p; } /* * Map object identified by link object sodp which was found in link * map smp. Returns a pointer to the link map for the requested object. * * On failure, it sets an error message that can be retrieved by __dlerror, * and returns NULL. */ static struct so_map * map_object(sodp, smp) struct sod *sodp; struct so_map *smp; { struct _dynamic *dp; char *path, *name = (char *)(sodp->sod_name + LM_LDBASE(smp)); int fd; caddr_t addr; struct exec hdr; int usehints = 0; struct so_map *p; struct somap_private *smpp; if (sodp->sod_library) { usehints = 1; again: path = rtfindlib(name, sodp->sod_major, sodp->sod_minor, &usehints); if (path == NULL) { generror ("Can't find shared library" " \"lib%s.so.%d.%d\"", name, sodp->sod_major, sodp->sod_minor); return NULL; } } else { if (careful && *name != '/') { generror ("Shared library path must start with \"/\" for \"%s\"", name); return NULL; } path = name; } /* Check if already loaded */ for (p = link_map_head; p; p = p->som_next) if (p->som_path && strcmp(p->som_path, path) == 0) break; if (p != NULL) return p; if ((fd = open(path, O_RDONLY, 0)) == -1) { if (usehints) { usehints = 0; goto again; } generror ("open failed for \"%s\" : %s", path, strerror (errno)); return NULL; } if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) { generror ("header read failed for \"%s\"", path); (void)close(fd); return NULL; } if (N_BADMAG(hdr)) { generror ("bad magic number in \"%s\"", path); (void)close(fd); return NULL; } if ((addr = mmap(0, hdr.a_text + hdr.a_data + hdr.a_bss, PROT_READ|PROT_EXEC, MAP_COPY, fd, 0)) == (caddr_t)-1) { generror ("mmap failed for \"%s\" : %s", path, strerror (errno)); (void)close(fd); return NULL; } if (mprotect(addr + hdr.a_text, hdr.a_data, PROT_READ|PROT_WRITE|PROT_EXEC) != 0) { generror ("mprotect failed for \"%s\" : %s", path, strerror (errno)); (void)close(fd); return NULL; } if (mmap(addr + hdr.a_text + hdr.a_data, hdr.a_bss, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_COPY|MAP_FIXED, anon_fd, 0) == (caddr_t)-1) { generror ("mmap failed for \"%s\" : %s", path, strerror (errno)); (void)close(fd); return NULL; } (void)close(fd); /* Assume _DYNAMIC is the first data item */ dp = (struct _dynamic *)(addr+hdr.a_text); /* Fixup __DYNAMIC structure */ (long)dp->d_un.d_sdt += (long)addr; p = alloc_link_map(path, sodp, smp, addr, dp); /* save segment sizes for unmap. */ smpp = LM_PRIVATE(p); smpp->a_text = hdr.a_text; smpp->a_data = hdr.a_data; smpp->a_bss = hdr.a_bss; return p; } /* * Unmap an object that is nolonger in use. */ static int unmap_object(smp) struct so_map *smp; { struct so_map *prev, *p; struct somap_private *smpp; /* Find the object in the list and unlink it */ for (prev = NULL, p = link_map_head; p != smp; prev = p, p = p->som_next) continue; if (prev == NULL) { link_map_head = smp->som_next; if (smp->som_next == NULL) link_map_tail = &link_map_head; } else { prev->som_next = smp->som_next; if (smp->som_next == NULL) link_map_tail = &prev->som_next; } /* Unmap the sections we have mapped */ smpp = LM_PRIVATE(smp); if (munmap(smp->som_addr, smpp->a_text + smpp->a_data) < 0) { generror ("munmap failed: %s", strerror (errno)); return -1; } if (smpp->a_bss > 0) { if (munmap(smp->som_addr + smpp->a_text + smpp->a_data, smpp->a_bss) < 0) { generror ("munmap failed: %s", strerror (errno)); return -1; } } if (smp->som_path) free(smp->som_path); free(smp); return 0; } static inline int check_text_reloc(r, smp, addr) struct relocation_info *r; struct so_map *smp; caddr_t addr; { char *sym; if (addr >= LM_ETEXT(smp)) return 0; if (RELOC_EXTERN_P(r)) sym = LM_STRINGS(smp) + LM_SYMBOL(smp, RELOC_SYMBOL(r))->nz_strx; else sym = ""; if (getenv("LD_SUPPRESS_WARNINGS") == NULL && getenv("LD_WARN_NON_PURE_CODE") != NULL) warnx("warning: non pure code in %s at %x (%s)", smp->som_path, r->r_address, sym); if (smp->som_write == 0 && mprotect(smp->som_addr + LM_TXTADDR(smp), LD_TEXTSZ(smp->som_dynamic), PROT_READ|PROT_WRITE|PROT_EXEC) == -1) { generror ("mprotect failed for \"%s\" : %s", smp->som_path, strerror (errno)); return -1; } smp->som_write = 1; return 0; } static int reloc_map(smp) struct so_map *smp; { struct _dynamic *dp = smp->som_dynamic; struct relocation_info *r = LM_REL(smp); struct relocation_info *rend = r + LD_RELSZ(dp)/sizeof(*r); long symbolbase = (long)LM_SYMBOL(smp, 0); char *stringbase = LM_STRINGS(smp); int symsize = LD_VERSION_NZLIST_P(dp->d_version) ? sizeof(struct nzlist) : sizeof(struct nlist); if(symmemosyms != 0) { /* * We have allocated space for a memorizing vector large * enough to hold "symmemosyms" symbols. Currently, the * code is written in such a way that the vector will * always be large enough, if it is present at all. But * this routine will still handle the case where there * is a memorizing vector, but it is smaller than what * is needed for the current shared object. */ long numsyms; size_t symmemobytes; numsyms = (LD_STRINGS(dp) - LD_SYMBOL(dp)) / symsize; if(numsyms > symmemosyms) /* Currently, this won't happen */ numsyms = symmemosyms; symmemobytes = numsyms * sizeof(struct memoent); bzero(symmemo, symmemobytes); } if (LD_PLTSZ(dp)) md_fix_jmpslot(LM_PLT(smp), (long)LM_PLT(smp), (long)binder_entry); for (; r < rend; r++) { char *sym; caddr_t addr = smp->som_addr + r->r_address; if (check_text_reloc(r, smp, addr) < 0) return -1; if (RELOC_EXTERN_P(r)) { struct so_map *src_map = NULL; struct nzlist *p, *np; long relocation; if (RELOC_LAZY_P(r)) continue; p = (struct nzlist *) (symbolbase + symsize * RELOC_SYMBOL(r)); if (p->nz_type == (N_SETV + N_EXT)) src_map = smp; sym = stringbase + p->nz_strx; if(RELOC_SYMBOL(r) < symmemosyms) { /* Check the memorizing vector */ np = symmemo[RELOC_SYMBOL(r)].np; if(np != NULL) { /* We found it */ src_map = symmemo[RELOC_SYMBOL(r)].src_map; } else { /* Symbol not memorized yet */ np = lookup(sym, &src_map, 0/*XXX-jumpslots!*/); /* * Record the needed information about * the symbol in the memorizing vector, * so that we won't have to call * lookup the next time we encounter * the symbol. */ symmemo[RELOC_SYMBOL(r)].np = np; symmemo[RELOC_SYMBOL(r)].src_map = src_map; } } else np = lookup(sym, &src_map, 0/*XXX-jumpslots!*/); if (np == NULL) { generror ("Undefined symbol \"%s\" in %s:%s", sym, main_progname, smp->som_path); return -1; } /* * Found symbol definition. * If it's in a link map, adjust value * according to the load address of that map. * Otherwise it's a run-time allocated common * whose value is already up-to-date. */ relocation = md_get_addend(r, addr); relocation += np->nz_value; if (src_map) relocation += (long)src_map->som_addr; if (RELOC_PCREL_P(r)) relocation -= (long)smp->som_addr; if (RELOC_COPY_P(r) && src_map) { (void)enter_rts(sym, (long)addr, N_DATA + N_EXT, src_map->som_addr + np->nz_value, np->nz_size, src_map); continue; } md_relocate(r, relocation, addr, 0); } else { md_relocate(r, #ifdef SUN_COMPAT md_get_rt_segment_addend(r, addr) #else md_get_addend(r, addr) #endif + (long)smp->som_addr, addr, 0); } } if (smp->som_write) { if (mprotect(smp->som_addr + LM_TXTADDR(smp), LD_TEXTSZ(smp->som_dynamic), PROT_READ|PROT_EXEC) == -1) { generror ("mprotect failed for \"%s\" : %s", smp->som_path, strerror (errno)); return -1; } smp->som_write = 0; } return 0; } static void reloc_copy(smp) struct so_map *smp; { struct rt_symbol *rtsp; for (rtsp = rt_symbol_head; rtsp; rtsp = rtsp->rt_next) if ((rtsp->rt_smp == NULL || rtsp->rt_smp == smp) && rtsp->rt_sp->nz_type == N_DATA + N_EXT) { bcopy(rtsp->rt_srcaddr, (caddr_t)rtsp->rt_sp->nz_value, rtsp->rt_sp->nz_size); } } static void init_map(smp, sym, dependants) struct so_map *smp; char *sym; int dependants; { struct so_map *src_map = smp; struct nzlist *np; if (LM_PRIVATE(smp)->spd_flags & RTLD_INIT) return; LM_PRIVATE(smp)->spd_flags |= RTLD_INIT; if (dependants) { struct sod *sodp; struct so_map *smp2; long next; next = LD_NEED(smp->som_dynamic); while (next) { sodp = (struct sod *)(LM_LDBASE(smp) + next); smp2 = find_object(sodp, smp); if (smp2) init_map(smp2, sym, dependants); next = sodp->sod_next; } } np = lookup(sym, &src_map, 1); if (np) (*(void (*)())(src_map->som_addr + np->nz_value))(); } static void call_map(smp, sym) struct so_map *smp; char *sym; { struct so_map *src_map = smp; struct nzlist *np; np = lookup(sym, &src_map, 1); if (np) (*(void (*)())(src_map->som_addr + np->nz_value))(); } /* * Load an object with all its dependant objects, recording the type of the * object and optionally calling its init function. */ static struct so_map * load_object(sodp, parent, type, init) struct sod *sodp; struct so_map *parent; int type; int init; { struct so_map* smp; /* * Find or map the object. */ smp = map_object(sodp, parent); if (smp == NULL) return NULL; /* * The first time the object is mapped, load it's dependant objects and * relocate it. */ if (LM_PRIVATE(smp)->spd_refcount++ == 0) { struct sod *sodp; struct so_map *smp2; long next; next = LD_NEED(smp->som_dynamic); /* * Load dependant objects but defer initialisation until later. * When all the dependants (and sub dependants, etc.) have been * loaded and relocated, it is safe to call the init functions, * using a recursive call to init_map. This ensures that if init * code in the dependants calls code in the parent, it will work * as expected. */ while (next) { sodp = (struct sod *)(LM_LDBASE(smp) + next); /* * Dependant objects (of both dlopen and main) don't get a * specific type. */ if ((smp2 = load_object(sodp, smp, 0, 0)) == NULL) { #ifdef DEBUG xprintf("ld.so: map_object failed on cascaded %s %s (%d.%d): %s\n", smp->sod_library ? "library" : "file", smp->sod_name, smp->sod_major, smp->sod_minor, strerror(errno)); #endif unload_object(smp); return NULL; } next = sodp->sod_next; } LM_PRIVATE(smp)->spd_flags |= type; if (reloc_map(smp) < 0) { unload_object(smp); return NULL; } reloc_copy(smp); if (init) { init_map(smp, ".init", 1); } } return smp; } /* * Unload an object, recursively unloading dependant objects. */ static int unload_object(smp) struct so_map *smp; { struct so_map *smp2; struct sod *sodp; long next; if (--LM_PRIVATE(smp)->spd_refcount != 0) return -1; /* * Call destructors for the object (before unloading its dependants * since destructors may use them. Only call destructors if constructors * have been called. */ if (LM_PRIVATE(smp)->spd_flags & RTLD_INIT) call_map(smp, ".fini"); /* * Unmap any dependant objects first. */ next = LD_NEED(smp->som_dynamic); while (next) { sodp = (struct sod *)(LM_LDBASE(smp) + next); smp2 = find_object(sodp, smp); if (smp2) unload_object(smp2); next = sodp->sod_next; } /* * Remove from address space. */ if (unmap_object(smp) < 0) return -1; return 0; } /* * Run-time common symbol table. */ #define RTC_TABSIZE 57 static struct rt_symbol *rt_symtab[RTC_TABSIZE]; /* * Compute hash value for run-time symbol table */ static inline int hash_string(key) char *key; { register char *cp; register int k; cp = key; k = 0; while (*cp) k = (((k << 1) + (k >> 14)) ^ (*cp++)) & 0x3fff; return k; } /* * Lookup KEY in the run-time common symbol table. */ static inline struct rt_symbol * lookup_rts(key) char *key; { register int hashval; register struct rt_symbol *rtsp; /* Determine which bucket. */ hashval = hash_string(key) % RTC_TABSIZE; /* Search the bucket. */ for (rtsp = rt_symtab[hashval]; rtsp; rtsp = rtsp->rt_link) if (strcmp(key, rtsp->rt_sp->nz_name) == 0) return rtsp; return NULL; } static struct rt_symbol * enter_rts(name, value, type, srcaddr, size, smp) char *name; long value; int type; caddr_t srcaddr; long size; struct so_map *smp; { register int hashval; register struct rt_symbol *rtsp, **rpp; /* Determine which bucket */ hashval = hash_string(name) % RTC_TABSIZE; /* Find end of bucket */ for (rpp = &rt_symtab[hashval]; *rpp; rpp = &(*rpp)->rt_link) continue; /* Allocate new common symbol */ rtsp = (struct rt_symbol *)malloc(sizeof(struct rt_symbol)); rtsp->rt_sp = (struct nzlist *)malloc(sizeof(struct nzlist)); rtsp->rt_sp->nz_name = strdup(name); rtsp->rt_sp->nz_value = value; rtsp->rt_sp->nz_type = type; rtsp->rt_sp->nz_size = size; rtsp->rt_srcaddr = srcaddr; rtsp->rt_smp = smp; rtsp->rt_link = NULL; /* Link onto linear list as well */ rtsp->rt_next = rt_symbol_head; rt_symbol_head = rtsp; *rpp = rtsp; return rtsp; } /* * Lookup NAME in the link maps. The link map producing a definition * is returned in SRC_MAP. If SRC_MAP is not NULL on entry the search is * confined to that map. If STRONG is set, the symbol returned must * have a proper type (used by binder()). */ static struct nzlist * lookup(name, src_map, strong) char *name; struct so_map **src_map; /* IN/OUT */ int strong; { long common_size = 0; struct so_map *smp; struct rt_symbol *rtsp; if ((rtsp = lookup_rts(name)) != NULL) return rtsp->rt_sp; /* * Search all maps for a definition of NAME */ for (smp = link_map_head; smp; smp = smp->som_next) { int buckets; long hashval; struct rrs_hash *hp; char *cp; struct nzlist *np; /* Some local caching */ long symbolbase; struct rrs_hash *hashbase; char *stringbase; int symsize; if (*src_map && smp != *src_map) continue; if ((buckets = LD_BUCKETS(smp->som_dynamic)) == 0) continue; if (LM_PRIVATE(smp)->spd_flags & RTLD_RTLD) continue; restart: /* * Compute bucket in which the symbol might be found. */ for (hashval = 0, cp = name; *cp; cp++) hashval = (hashval << 1) + *cp; hashval = (hashval & 0x7fffffff) % buckets; hashbase = LM_HASH(smp); hp = hashbase + hashval; if (hp->rh_symbolnum == -1) /* Nothing in this bucket */ continue; symbolbase = (long)LM_SYMBOL(smp, 0); stringbase = LM_STRINGS(smp); symsize = LD_VERSION_NZLIST_P(smp->som_dynamic->d_version)? sizeof(struct nzlist) : sizeof(struct nlist); while (hp) { np = (struct nzlist *) (symbolbase + hp->rh_symbolnum * symsize); cp = stringbase + np->nz_strx; if (strcmp(cp, name) == 0) break; if (hp->rh_next == 0) hp = NULL; else hp = hashbase + hp->rh_next; } if (hp == NULL) /* Nothing in this bucket */ continue; /* * We have a symbol with the name we're looking for. */ if (np->nz_type == N_INDR+N_EXT) { /* * Next symbol gives the aliased name. Restart * search with new name and confine to this map. */ name = stringbase + (++np)->nz_strx; *src_map = smp; goto restart; } if (np->nz_value == 0) /* It's not a definition */ continue; if (np->nz_type == N_UNDF+N_EXT && np->nz_value != 0) { if (np->nz_other == AUX_FUNC) { /* It's a weak function definition */ if (strong) continue; } else { /* It's a common, note value and continue search */ if (common_size < np->nz_value) common_size = np->nz_value; continue; } } *src_map = smp; return np; } if (common_size == 0) /* Not found */ return NULL; /* * It's a common, enter into run-time common symbol table. */ rtsp = enter_rts(name, (long)calloc(1, common_size), N_UNDF + N_EXT, 0, common_size, NULL); #if DEBUG xprintf("Allocating common: %s size %d at %#x\n", name, common_size, rtsp->rt_sp->nz_value); #endif return rtsp->rt_sp; } /* * getMemory and freeMemory are special memory allocation routines * that use mmap rather than malloc. They are used for allocating * and freeing the symbol memorizing vector. This vector is somewhat * large (8 to 12 Kbytes, typically), and it is used only temporarily. * By using mmap to allocate it, we can then use munmap to free it. * That reduces the runtime size of every dynamically linked program. * * Don't use getMemory and freeMemory casually for frequent allocations * or for small allocations. */ static size_t pagesize; /* Avoids multiple calls to getpagesize() */ /* * Allocate a block of memory using mmap. */ static void * getMemory(size_t size) { caddr_t ptr; if(size == 0) /* That was easy */ return NULL; if(pagesize == 0) /* First call */ pagesize = getpagesize(); /* Round up the request to an even multiple of the page size */ size = (size + pagesize - 1) & ~(pagesize - 1); ptr = mmap(0, size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_COPY, anon_fd, 0); if(ptr == (caddr_t) -1) { xprintf("Cannot map anonymous memory"); return NULL; } return (void *) ptr; } /* * Free a block of memory, using munmap to return the memory to the system. */ static void freeMemory(void *ptr, size_t size) { if(ptr == NULL || size == 0) return; if(pagesize == 0) /* Really, should never happen */ pagesize = getpagesize(); /* Round up the size to an even multiple of the page size */ size = (size + pagesize - 1) & ~(pagesize - 1); if(munmap((caddr_t) ptr, size) == -1) xprintf("Cannot unmap anonymous memory"); } /* * This routine is called from the jumptable to resolve * procedure calls to shared objects. */ long binder(jsp) jmpslot_t *jsp; { struct so_map *smp, *src_map = NULL; long addr; char *sym; struct nzlist *np; int index; /* * Find the PLT map that contains JSP. */ for (smp = link_map_head; smp; smp = smp->som_next) { if (LM_PLT(smp) < jsp && jsp < LM_PLT(smp) + LD_PLTSZ(smp->som_dynamic)/sizeof(*jsp)) break; } if (smp == NULL) errx(1, "Call to binder from unknown location: %#x\n", jsp); index = jsp->reloc_index & JMPSLOT_RELOC_MASK; /* Get the local symbol this jmpslot refers to */ sym = LM_STRINGS(smp) + LM_SYMBOL(smp,RELOC_SYMBOL(&LM_REL(smp)[index]))->nz_strx; np = lookup(sym, &src_map, 1); if (np == NULL) errx(1, "Undefined symbol \"%s\" called from %s:%s at %#x", sym, main_progname, smp->som_path, jsp); /* Fixup jmpslot so future calls transfer directly to target */ addr = np->nz_value; if (src_map) addr += (long)src_map->som_addr; md_fix_jmpslot(jsp, (long)jsp, addr); #if DEBUG xprintf(" BINDER: %s located at = %#x in %s\n", sym, addr, src_map->som_path); #endif return addr; } static int hfd; static long hsize; static struct hints_header *hheader; static struct hints_bucket *hbuckets; static char *hstrtab; #define HINTS_VALID (hheader != NULL && hheader != (struct hints_header *)-1) static void maphints __P((void)) { caddr_t addr; if ((hfd = open(_PATH_LD_HINTS, O_RDONLY, 0)) == -1) { hheader = (struct hints_header *)-1; return; } hsize = PAGSIZ; addr = mmap(0, hsize, PROT_READ, MAP_COPY, hfd, 0); if (addr == (caddr_t)-1) { close(hfd); hheader = (struct hints_header *)-1; return; } hheader = (struct hints_header *)addr; if (HH_BADMAG(*hheader)) { munmap(addr, hsize); close(hfd); hheader = (struct hints_header *)-1; return; } if (hheader->hh_version != LD_HINTS_VERSION_1) { munmap(addr, hsize); close(hfd); hheader = (struct hints_header *)-1; return; } if (hheader->hh_ehints > hsize) { if (mmap(addr+hsize, hheader->hh_ehints - hsize, PROT_READ, MAP_COPY|MAP_FIXED, hfd, hsize) != (caddr_t)(addr+hsize)) { munmap((caddr_t)hheader, hsize); close(hfd); hheader = (struct hints_header *)-1; return; } } hbuckets = (struct hints_bucket *)(addr + hheader->hh_hashtab); hstrtab = (char *)(addr + hheader->hh_strtab); } static void unmaphints() { if (HINTS_VALID) { munmap((caddr_t)hheader, hsize); close(hfd); hheader = NULL; } } int hinthash(cp, vmajor) char *cp; int vmajor; { int k = 0; while (*cp) k = (((k << 1) + (k >> 14)) ^ (*cp++)) & 0x3fff; k = (((k << 1) + (k >> 14)) ^ (vmajor*257)) & 0x3fff; return k; } #undef major #undef minor static char * findhint(name, major, minor, preferred_path) char *name; int major, minor; char *preferred_path; { struct hints_bucket *bp; bp = hbuckets + (hinthash(name, major) % hheader->hh_nbucket); while (1) { /* Sanity check */ if (bp->hi_namex >= hheader->hh_strtab_sz) { warnx("Bad name index: %#x\n", bp->hi_namex); break; } if (bp->hi_pathx >= hheader->hh_strtab_sz) { warnx("Bad path index: %#x\n", bp->hi_pathx); break; } if (strcmp(name, hstrtab + bp->hi_namex) == 0) { /* It's `name', check version numbers */ if (bp->hi_major == major && (bp->hi_ndewey < 2 || bp->hi_minor >= minor)) { if (preferred_path == NULL || strcmp(preferred_path, hstrtab + bp->hi_pathx) == 0) { return hstrtab + bp->hi_pathx; } } } if (bp->hi_next == -1) break; /* Move on to next in bucket */ bp = &hbuckets[bp->hi_next]; } /* No hints available for name */ return NULL; } static char * rtfindlib(name, major, minor, usehints) char *name; int major, minor; int *usehints; { char *cp, *ld_path = getenv("LD_LIBRARY_PATH"); int realminor; if (hheader == NULL) maphints(); if (!HINTS_VALID || !(*usehints)) goto lose; if (ld_path != NULL) { /* Prefer paths from LD_LIBRARY_PATH */ while ((cp = strsep(&ld_path, ":")) != NULL) { cp = findhint(name, major, minor, cp); if (ld_path) *(ld_path-1) = ':'; if (cp) return cp; } /* Not found in hints, try directory search */ realminor = -1; cp = (char *)findshlib(name, &major, &realminor, 0); if (cp && realminor >= minor) return cp; } /* No LD_LIBRARY_PATH or lib not found in there; check default */ cp = findhint(name, major, minor, NULL); if (cp) return cp; lose: /* No hints available for name */ *usehints = 0; realminor = -1; cp = (char *)findshlib(name, &major, &realminor, 0); if (cp) { if (realminor < minor && getenv("LD_SUPPRESS_WARNINGS") == NULL) warnx("warning: lib%s.so.%d.%d: " "minor version < %d expected, using it anyway", name, major, realminor, minor); return cp; } generror ("Can't find shared library \"%s\"", name); return NULL; } static struct somap_private dlmap_private = { 0, (struct so_map *)0, 0, #ifdef SUN_COMPAT 0, #endif }; static struct so_map dlmap = { (caddr_t)0, "internal", (struct so_map *)0, (struct sod *)0, (caddr_t)0, (u_int)0, (struct _dynamic *)0, (caddr_t)&dlmap_private }; /* * Buffer for error messages and a pointer that is set to point to the buffer * when a error occurs. It acts as a last error flag, being set to NULL * after an error is returned. */ #define DLERROR_BUF_SIZE 512 static char dlerror_buf [DLERROR_BUF_SIZE]; static char *dlerror_msg = NULL; static void * __dlopen(name, mode) char *name; int mode; { struct sod *sodp; struct so_map *smp; /* * A NULL argument returns the current set of mapped objects. */ if (name == NULL) { LM_PRIVATE(link_map_head)->spd_refcount++; return link_map_head; } if ((sodp = (struct sod *)malloc(sizeof(struct sod))) == NULL) { generror ("malloc failed: %s", strerror (errno)); return NULL; } sodp->sod_name = (long)strdup(name); sodp->sod_library = 0; sodp->sod_major = sodp->sod_minor = 0; if ((smp = load_object(sodp, &dlmap, RTLD_DL, 1)) == NULL) { #ifdef DEBUG xprintf("%s: %s\n", name, dlerror_buf); #endif return NULL; } /* * If this was newly loaded, call the _init() function in the * object as per manpage. */ if (LM_PRIVATE(smp)->spd_refcount == 1) call_map(smp, "__init"); return smp; } static int __dlclose(fd) void *fd; { struct so_map *smp = (struct so_map *)fd; #ifdef DEBUG xprintf("dlclose(%s): refcount = %d\n", smp->som_path, LM_PRIVATE(smp)->spd_refcount); #endif if (smp == NULL) { generror("NULL argument to dlclose"); return -1; } if (LM_PRIVATE(smp)->spd_refcount > 1) { LM_PRIVATE(smp)->spd_refcount--; return 0; } /* * Call the function _fini() in the object as per manpage. */ call_map(smp, "__fini"); free((void*) smp->som_sod->sod_name); free(smp->som_sod); if (unload_object(smp) < 0) return -1; return 0; } static void * __dlsym(fd, sym) void *fd; char *sym; { struct so_map *smp = (struct so_map *)fd, *src_map = NULL; struct nzlist *np; long addr; /* * Restrict search to passed map if dlopen()ed. */ if (smp && LM_PRIVATE(smp)->spd_flags & RTLD_DL) src_map = smp; np = lookup(sym, &src_map, 1); if (np == NULL) { generror ("Symbol \"%s\" not found", sym); return NULL; } /* Fixup jmpslot so future calls transfer directly to target */ addr = np->nz_value; if (src_map) addr += (long)src_map->som_addr; return (void *)addr; } static char * __dlerror __P((void)) { char *err; err = dlerror_msg; dlerror_msg = NULL; /* Next call will return NULL */ return err; } static void __dlexit __P((void)) { struct so_map *smp; for (smp = link_map_head; smp; smp = smp->som_next) { if (LM_PRIVATE(smp)->spd_flags & (RTLD_RTLD|RTLD_MAIN)) continue; call_map(smp, ".fini"); } } /* * Generate an error message that can be later be retrieved via dlerror. */ static void #if __STDC__ generror(char *fmt, ...) #else generror(fmt, va_alist) char *fmt; #endif { va_list ap; #if __STDC__ va_start(ap, fmt); #else va_start(ap); #endif vsnprintf (dlerror_buf, DLERROR_BUF_SIZE, fmt, ap); dlerror_msg = dlerror_buf; va_end(ap); } void #if __STDC__ xprintf(char *fmt, ...) #else xprintf(fmt, va_alist) char *fmt; #endif { char buf[256]; va_list ap; #if __STDC__ va_start(ap, fmt); #else va_start(ap); #endif vsprintf(buf, fmt, ap); (void)write(1, buf, strlen(buf)); va_end(ap); }