From 66fdbc00cfad3be604d07da78b916f4c04f96dbc Mon Sep 17 00:00:00 2001 From: paul Date: Wed, 3 Nov 1993 23:41:59 +0000 Subject: Imported NetBSD's ld for shared libs. --- libexec/rtld-aout/Makefile | 24 + libexec/rtld-aout/i386/md-static-funcs.c | 15 + libexec/rtld-aout/i386/md.c | 329 ++++++++++ libexec/rtld-aout/i386/md.h | 198 ++++++ libexec/rtld-aout/i386/mdprologue.S | 124 ++++ libexec/rtld-aout/md-prologue.c | 39 ++ libexec/rtld-aout/rtld.c | 1026 ++++++++++++++++++++++++++++++ libexec/rtld-aout/shlib.c | 203 ++++++ 8 files changed, 1958 insertions(+) create mode 100644 libexec/rtld-aout/Makefile create mode 100644 libexec/rtld-aout/i386/md-static-funcs.c create mode 100644 libexec/rtld-aout/i386/md.c create mode 100644 libexec/rtld-aout/i386/md.h create mode 100644 libexec/rtld-aout/i386/mdprologue.S create mode 100644 libexec/rtld-aout/md-prologue.c create mode 100644 libexec/rtld-aout/rtld.c create mode 100644 libexec/rtld-aout/shlib.c (limited to 'libexec') diff --git a/libexec/rtld-aout/Makefile b/libexec/rtld-aout/Makefile new file mode 100644 index 0000000..ea02608 --- /dev/null +++ b/libexec/rtld-aout/Makefile @@ -0,0 +1,24 @@ +# $Id: Makefile,v 1.2 1993/10/27 00:55:24 pk Exp $ + +PROG= ld.so +SRCS= mdprologue.S rtld.c shlib.c etc.c md.c +NOMAN= noman +LDDIR?= $(.CURDIR)/.. +#PICFLAG=-pic +PICFLAG=-fpic +CFLAGS += -I$(LDDIR) -I$(.CURDIR) -I$(LDDIR)/$(MACHINE) -O $(PICFLAG) -DRTLD +LDFLAGS = -Bshareable -Bsymbolic -assert nosymbolic +LIBS = -lc_pic +BINDIR= /usr/libexec + +.PATH: $(LDDIR) $(LDDIR)/$(MACHINE) + +.SUFFIXES: .S + +$(PROG): + $(LD) -o $(PROG) $(LDFLAGS) $(OBJS) $(LIBS) + +.S.o: + $(CPP) $(.IMPSRC) | $(AS) -k -o $(.TARGET) - + +.include diff --git a/libexec/rtld-aout/i386/md-static-funcs.c b/libexec/rtld-aout/i386/md-static-funcs.c new file mode 100644 index 0000000..2cd0768 --- /dev/null +++ b/libexec/rtld-aout/i386/md-static-funcs.c @@ -0,0 +1,15 @@ + +/* + * Called by ld.so when onanating. + * This *must* be a static function, so it is not called through a jmpslot. + */ +static void +md_relocate_simple(r, relocation, addr) +struct relocation_info *r; +long relocation; +char *addr; +{ +if (r->r_relative) + *(long *)addr += relocation; +} + diff --git a/libexec/rtld-aout/i386/md.c b/libexec/rtld-aout/i386/md.c new file mode 100644 index 0000000..bfe12e9 --- /dev/null +++ b/libexec/rtld-aout/i386/md.c @@ -0,0 +1,329 @@ +/* + * 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 withough 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: md.c,v 1.2 1993/10/27 00:54:58 pk Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ld.h" + +/* + * Get relocation addend corresponding to relocation record RP + * from address ADDR + */ +long +md_get_addend(rp, addr) +struct relocation_info *rp; +unsigned char *addr; +{ + switch (RELOC_TARGET_SIZE(rp)) { + case 0: + return get_byte(addr); + break; + case 1: + return get_short(addr); + break; + case 2: + return get_long(addr); + break; + } +} + +/* + * Put RELOCATION at ADDR according to relocation record RP. + */ +void +md_relocate(rp, relocation, addr, relocatable_output) +struct relocation_info *rp; +long relocation; +unsigned char *addr; +{ + switch (RELOC_TARGET_SIZE(rp)) { + case 0: + put_byte(addr, relocation); + break; + case 1: + put_short(addr, relocation); + break; + case 2: + put_long(addr, relocation); + break; + default: + fatal("Unsupported relocation size: %x", RELOC_TARGET_SIZE(rp)); + } +} + +/* + * Initialize (output) exec header such that useful values are + * obtained from subsequent N_*() macro evaluations. + */ +void +md_init_header(hp, magic, flags) +struct exec *hp; +int magic, flags; +{ + N_SETMAGIC((*hp), magic, MID_I386, flags); + + /* TEXT_START depends on the value of outheader.a_entry. */ + if (!(link_mode & SHAREABLE)) /*WAS: if (entry_symbol) */ + hp->a_entry = PAGSIZ; +} + +/* + * Machine dependent part of claim_rrs_reloc(). + * Set RRS relocation type. + */ +int +md_make_reloc(rp, r, type) +struct relocation_info *rp, *r; +int type; +{ + /* Relocation size */ + r->r_length = rp->r_length; + + if (RELOC_PCREL_P(rp)) + r->r_pcrel = 1; + + if (type & RELTYPE_RELATIVE) + r->r_relative = 1; + + if (type & RELTYPE_COPY) + r->r_copy = 1; + + return 0; +} + +/* + * Set up a transfer from jmpslot at OFFSET (relative to the PLT table) + * to the binder slot (which is at offset 0 of the PLT). + */ +void +md_make_jmpslot(sp, offset, index) +jmpslot_t *sp; +long offset; +long index; +{ + /* + * i386 PC-relative "fixed point" is located right after the + * instruction it pertains to. + */ + u_long fudge = - (sizeof(sp->opcode) + sizeof(sp->addr) + offset); + + sp->opcode = CALL; +#if 0 + sp->addr = fudge; +#else + sp->addr[0] = fudge & 0xffff; + sp->addr[1] = fudge >> 16; +#endif + sp->reloc_index = index; +} + +/* + * Set up a "direct" transfer (ie. not through the run-time binder) from + * jmpslot at OFFSET to ADDR. Used by `ld' when the SYMBOLIC flag is on, + * and by `ld.so' after resolving the symbol. + * On the i386, we use the JMP instruction which is PC relative, so no + * further RRS relocations will be necessary for such a jmpslot. + */ +void +md_fix_jmpslot(sp, offset, addr) +jmpslot_t *sp; +long offset; +u_long addr; +{ + u_long fudge = addr - (sizeof(sp->opcode) + sizeof(sp->addr) + offset); + + sp->opcode = JUMP; +#if 0 + sp->addr = fudge; +#else + sp->addr[0] = fudge & 0xffff; + sp->addr[1] = fudge >> 16; +#endif + sp->reloc_index = 0; +} + +/* + * Update the relocation record for a RRS jmpslot. + */ +void +md_make_jmpreloc(rp, r, type) +struct relocation_info *rp, *r; +int type; +{ + jmpslot_t *sp; + + /* + * Fix relocation address to point to the correct + * location within this jmpslot. + */ + r->r_address += sizeof(sp->opcode); + + /* Relocation size */ + r->r_length = 2; + + /* Set relocation type */ + r->r_jmptable = 1; + if (type & RELTYPE_RELATIVE) + r->r_relative = 1; + +} + +/* + * Set relocation type for a RRS GOT relocation. + */ +void +md_make_gotreloc(rp, r, type) +struct relocation_info *rp, *r; +int type; +{ + r->r_baserel = 1; + if (type & RELTYPE_RELATIVE) + r->r_relative = 1; + + /* Relocation size */ + r->r_length = 2; +} + +/* + * Set relocation type for a RRS copy operation. + */ +void +md_make_cpyreloc(rp, r) +struct relocation_info *rp, *r; +{ + /* Relocation size */ + r->r_length = 2; + + r->r_copy = 1; +} + + +#ifdef NEED_SWAP + +/* + * Byte swap routines for cross-linking. + */ + +void +md_swapin_exec_hdr(h) +struct exec *h; +{ + int skip = 0; + + if (!N_BADMAG(*h)) + skip = 1; + + swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip); +} + +void +md_swapout_exec_hdr(h) +struct exec *h; +{ + /* NetBSD: Always leave magic alone */ + int skip = 1; +#if 0 + if (N_GETMAGIC(*h) == OMAGIC) + skip = 0; +#endif + + swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip); +} + + +void +md_swapin_reloc(r, n) +struct relocation_info *r; +int n; +{ + int bits; + + for (; n; n--, r++) { + r->r_address = md_swap_long(r->r_address); + bits = ((int *)r)[1]; + r->r_symbolnum = md_swap_long(bits & 0xffffff00); + r->r_pcrel = (bits & 1); + r->r_length = ((bits >> 1) & 3); + r->r_extern = ((bits >> 3) & 1); + r->r_baserel = ((bits >> 4) & 1); + r->r_jmptable = ((bits >> 5) & 1); + r->r_relative = ((bits >> 6) & 1); +#ifdef N_SIZE + r->r_copy = ((bits >> 7) & 1); +#endif + } +} + +void +md_swapout_reloc(r, n) +struct relocation_info *r; +int n; +{ + int bits; + + for (; n; n--, r++) { + r->r_address = md_swap_long(r->r_address); + bits = (md_swap_long(r->r_symbolnum) & 0xffffff00); + bits |= (r->r_pcrel & 1); + bits |= ((r->r_length << 1) & 6); + bits |= ((r->r_extern << 3) & 8); + bits |= ((r->r_baserel << 4) & 0x10); + bits |= ((r->r_jmptable << 5) & 0x20); + bits |= ((r->r_relative << 6) & 0x40); +#ifdef N_SIZE + bits |= ((r->r_copy << 7) & 0x80); +#endif + ((int *)r)[1] = bits; + } +} + +void +md_swapout_jmpslot(j, n) +jmpslot_t *j; +int n; +{ + for (; n; n--, j++) { + j->opcode = md_swap_short(j->opcode); + j->addr[0] = md_swap_short(j->addr[0]); + j->addr[1] = md_swap_short(j->addr[1]); + j->reloc_index = md_swap_short(j->reloc_index); + } +} + +#endif /* NEED_SWAP */ diff --git a/libexec/rtld-aout/i386/md.h b/libexec/rtld-aout/i386/md.h new file mode 100644 index 0000000..ecd1815 --- /dev/null +++ b/libexec/rtld-aout/i386/md.h @@ -0,0 +1,198 @@ +/* + * $Id: md.h,v 1.3 1993/10/24 00:52:40 pk Exp $ - I386 dependent definitions + */ + + +#if defined(CROSS_LINKER) && defined(XHOST) && XHOST==sparc + +#define NEED_SWAP + +#endif + +#define MAX_ALIGNMENT (sizeof (long)) + +#ifdef NetBSD +#define PAGSIZ __LDPGSZ +#else +#define PAGSIZ 4096 +#endif + +#define N_SET_FLAG(ex,f) N_SETMAGIC(ex,N_GETMAGIC(ex), MID_MACHINE, \ + N_GETFLAG(ex)|(f)) + +#define N_IS_DYNAMIC(ex) ((N_GETFLAG(ex) & EX_DYNAMIC)) + +/* + * Should be handled by a.out.h ? + */ +#define N_ADJUST(ex) (((ex).a_entry < PAGSIZ) ? -PAGSIZ : 0) +#define TEXT_START(ex) (N_TXTADDR(ex) + N_ADJUST(ex)) +#define DATA_START(ex) (N_DATADDR(ex) + N_ADJUST(ex)) + +#define RELOC_STATICS_THROUGH_GOT_P(r) (0) +#define JMPSLOT_NEEDS_RELOC (0) + +#define md_got_reloc(r) (0) + +#define md_get_rt_segment_addend(r,a) md_get_addend(r,a) + +/* Width of a Global Offset Table entry */ +#define GOT_ENTRY_SIZE 4 +typedef long got_t; + +typedef struct jmpslot { + u_short opcode; + u_short addr[2]; + u_short reloc_index; +#define JMPSLOT_RELOC_MASK 0xffff +} jmpslot_t; + +#define NOP 0x90 +#define CALL 0xe890 /* NOP + CALL opcode */ +#define JUMP 0xe990 /* NOP + JMP opcode */ +#define TRAP 0xcc /* INT 3 */ + +/* + * Byte swap defs for cross linking + */ + +#if !defined(NEED_SWAP) + +#define md_swapin_exec_hdr(h) +#define md_swapout_exec_hdr(h) +#define md_swapin_symbols(s,n) +#define md_swapout_symbols(s,n) +#define md_swapin_zsymbols(s,n) +#define md_swapout_zsymbols(s,n) +#define md_swapin_reloc(r,n) +#define md_swapout_reloc(r,n) +#define md_swapin_link_dynamic(l) +#define md_swapout_link_dynamic(l) +#define md_swapin_link_dynamic_2(l) +#define md_swapout_link_dynamic_2(l) +#define md_swapin_ld_debug(d) +#define md_swapout_ld_debug(d) +#define md_swapin_rrs_hash(f,n) +#define md_swapout_rrs_hash(f,n) +#define md_swapin_link_object(l,n) +#define md_swapout_link_object(l,n) +#define md_swapout_jmpslot(j,n) +#define md_swapout_got(g,n) +#define md_swapin_ranlib_hdr(h,n) +#define md_swapout_ranlib_hdr(h,n) + +#endif /* NEED_SWAP */ + +#ifdef CROSS_LINKER + +#ifdef NEED_SWAP + +/* Define IO byte swapping routines */ + +void md_swapin_exec_hdr __P((struct exec *)); +void md_swapout_exec_hdr __P((struct exec *)); +void md_swapin_reloc __P((struct relocation_info *, int)); +void md_swapout_reloc __P((struct relocation_info *, int)); +void md_swapout_jmpslot __P((jmpslot_t *, int)); + +#define md_swapin_symbols(s,n) swap_symbols(s,n) +#define md_swapout_symbols(s,n) swap_symbols(s,n) +#define md_swapin_zsymbols(s,n) swap_zsymbols(s,n) +#define md_swapout_zsymbols(s,n) swap_zsymbols(s,n) +#define md_swapin_link_dynamic(l) swap_link_dynamic(l) +#define md_swapout_link_dynamic(l) swap_link_dynamic(l) +#define md_swapin_link_dynamic_2(l) swap_link_dynamic_2(l) +#define md_swapout_link_dynamic_2(l) swap_link_dynamic_2(l) +#define md_swapin_ld_debug(d) swap_ld_debug(d) +#define md_swapout_ld_debug(d) swap_ld_debug(d) +#define md_swapin_rrs_hash(f,n) swap_rrs_hash(f,n) +#define md_swapout_rrs_hash(f,n) swap_rrs_hash(f,n) +#define md_swapin_link_object(l,n) swapin_link_object(l,n) +#define md_swapout_link_object(l,n) swapout_link_object(l,n) +#define md_swapout_got(g,n) swap_longs((long*)(g),n) +#define md_swapin_ranlib_hdr(h,n) swap_ranlib_hdr(h,n) +#define md_swapout_ranlib_hdr(h,n) swap_ranlib_hdr(h,n) + +#define md_swap_short(x) ( (((x) >> 8) & 0xff) | (((x) & 0xff) << 8) ) + +#define md_swap_long(x) ( (((x) >> 24) & 0xff ) | (((x) >> 8 ) & 0xff00 ) | \ + (((x) << 8 ) & 0xff0000) | (((x) << 24) & 0xff000000)) + +#define get_byte(p) ( ((unsigned char *)(p))[0] ) + +#define get_short(p) ( ( ((unsigned char *)(p))[1] << 8) | \ + ( ((unsigned char *)(p))[0] ) \ + ) +#define get_long(p) ( ( ((unsigned char *)(p))[3] << 24) | \ + ( ((unsigned char *)(p))[2] << 16) | \ + ( ((unsigned char *)(p))[1] << 8 ) | \ + ( ((unsigned char *)(p))[0] ) \ + ) + +#define put_byte(p, v) { ((unsigned char *)(p))[0] = ((unsigned long)(v)); } + +#define put_short(p, v) { ((unsigned char *)(p))[1] = \ + ((((unsigned long)(v)) >> 8) & 0xff); \ + ((unsigned char *)(p))[0] = \ + ((((unsigned long)(v)) ) & 0xff); } + +#define put_long(p, v) { ((unsigned char *)(p))[3] = \ + ((((unsigned long)(v)) >> 24) & 0xff); \ + ((unsigned char *)(p))[2] = \ + ((((unsigned long)(v)) >> 16) & 0xff); \ + ((unsigned char *)(p))[1] = \ + ((((unsigned long)(v)) >> 8) & 0xff); \ + ((unsigned char *)(p))[0] = \ + ((((unsigned long)(v)) ) & 0xff); } + +#else /* We need not swap, but must pay attention to alignment: */ + +#define md_swap_short(x) (x) +#define md_swap_long(x) (x) + +#define get_byte(p) ( ((unsigned char *)(p))[0] ) + +#define get_short(p) ( ( ((unsigned char *)(p))[0] << 8) | \ + ( ((unsigned char *)(p))[1] ) \ + ) + +#define get_long(p) ( ( ((unsigned char *)(p))[0] << 24) | \ + ( ((unsigned char *)(p))[1] << 16) | \ + ( ((unsigned char *)(p))[2] << 8 ) | \ + ( ((unsigned char *)(p))[3] ) \ + ) + + +#define put_byte(p, v) { ((unsigned char *)(p))[0] = ((unsigned long)(v)); } + +#define put_short(p, v) { ((unsigned char *)(p))[0] = \ + ((((unsigned long)(v)) >> 8) & 0xff); \ + ((unsigned char *)(p))[1] = \ + ((((unsigned long)(v)) ) & 0xff); } + +#define put_long(p, v) { ((unsigned char *)(p))[0] = \ + ((((unsigned long)(v)) >> 24) & 0xff); \ + ((unsigned char *)(p))[1] = \ + ((((unsigned long)(v)) >> 16) & 0xff); \ + ((unsigned char *)(p))[2] = \ + ((((unsigned long)(v)) >> 8) & 0xff); \ + ((unsigned char *)(p))[3] = \ + ((((unsigned long)(v)) ) & 0xff); } + +#endif /* NEED_SWAP */ + +#else /* Not a cross linker: use native */ + +#define md_swap_short(x) (x) +#define md_swap_long(x) (x) + +#define get_byte(where) (*(char *)(where)) +#define get_short(where) (*(short *)(where)) +#define get_long(where) (*(long *)(where)) + +#define put_byte(where,what) (*(char *)(where) = (what)) +#define put_short(where,what) (*(short *)(where) = (what)) +#define put_long(where,what) (*(long *)(where) = (what)) + +#endif /* CROSS_LINKER */ + diff --git a/libexec/rtld-aout/i386/mdprologue.S b/libexec/rtld-aout/i386/mdprologue.S new file mode 100644 index 0000000..3b7a6da --- /dev/null +++ b/libexec/rtld-aout/i386/mdprologue.S @@ -0,0 +1,124 @@ +/* + * 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 withough 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: mdprologue.S,v 1.1 1993/10/16 21:53:16 pk Exp $ + */ + +/* + * i386 run-time link editor entry points. + */ + +#include +#define LCALL(x,y) .byte 0x9a ; .long y; .word x + + .text + .globl _binder, _binder_entry + +/* + * _rtl(int version, struct crt_ldso *crtp) + */ +#define FRAME 12 /* Size of stack frame */ + + +_rtl: # crt0 calls us here + pushl %ebp # Allocate stack frame + movl %esp, %ebp + subl $FRAME, %esp + pushl %ebx + call 1f # PIC function prologue +1: + popl %ebx + addl $_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx + + movl 12(%ebp), %eax # Extract data from interface structure + movl (%eax),%eax # base address of ld.so (first field) + # setup arguments for rtld() + movl (%ebx), %ecx # 1st entry in GOT is our __DYNAMIC + addl %eax, %ecx # add load address + pushl %ecx # 3rd arg + pushl 12(%ebp) # 2nd arg == &crt. + pushl 8(%ebp) # 1st arg == version + addl _rtld@GOT(%ebx), %eax # relocate address of function + call %eax # _rtld(version, crtp, DYNAMIC) + addl $12,%esp # pop arguments + + movl (-FRAME-4)(%ebp), %ebx # restore %ebx + leave # remove stack frame, + ret # let's rock + + # First call to a procedure generally comes through here for + # binding. + +_binder_entry: + pushl %ebp # setup a stack frame + movl %esp, %ebp + pusha # save all regs + + movl $0, %eax # clear + movl 4(%ebp), %esi # return address in PLT + movw (%esi), %ax # get hold of relocation number + subl $6, %esi # make it point to the jmpslot + + pushl %eax # pushd arguments + pushl %esi # + call _binder@PLT # _binder(rpc, index) + addl $8, %esp # pop arguments + movl %eax, 4(%ebp) # return value from _binder() == actual + # address of function + popa # restore regs + leave # remove our stack frame + ret + + # Special system call stubs which return real and effective user and group + # id's. Saves overhead of making separate calls for each. + # !! Relies on compatability option in BSD 4.three-and-a-half + + .globl _getreuid, _getregid +_getreuid: + lea SYS_getuid, %eax + LCALL(7,0) + jc out + movl 4(%esp), %ecx # get 1st arg + movl %eax, (%ecx) # put value in it + movl 8(%esp), %ecx # same for 2nd arg + movl %edx, (%ecx) # + ret # done + +_getregid: + lea SYS_getgid, %eax + LCALL(7,0) + jc out + movl 4(%esp), %ecx # get 1st arg + movl %eax, (%ecx) # put value in it + movl 8(%esp), %ecx # same for 2nd arg + movl %edx, (%ecx) # + ret # done + +out: jmp cerror@PLT # Call common error routine + diff --git a/libexec/rtld-aout/md-prologue.c b/libexec/rtld-aout/md-prologue.c new file mode 100644 index 0000000..dae455e --- /dev/null +++ b/libexec/rtld-aout/md-prologue.c @@ -0,0 +1,39 @@ +/* + * rtld entry pseudo code - turn into assembler and tweak it + */ + +#include +#include +#include +#include "link.h" +#include "md.h" + +extern long _GOT_[]; +extern void (*rtld)(); +extern void (*binder())(); + +void +rtld_entry(version, crtp) +int version; +struct crt *crtp; +{ + register struct link_dynamic *dp; + register void (*f)(); + + /* __DYNAMIC is first entry in GOT */ + dp = (struct link_dynamic *) (_GOT_[0]+crtp->crt_ba); + + f = (void (*)())((long)rtld + crtp->crt_ba); + (*f)(version, crtp, dp); +} + +void +binder_entry() +{ + extern int PC; + struct jmpslot *sp; + void (*func)(); + + func = binder(PC, sp->reloc_index & 0x003fffff); + (*func)(); +} diff --git a/libexec/rtld-aout/rtld.c b/libexec/rtld-aout/rtld.c new file mode 100644 index 0000000..433820a --- /dev/null +++ b/libexec/rtld-aout/rtld.c @@ -0,0 +1,1026 @@ +/* + * 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 withough 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.7 1993/11/03 21:35:54 pk Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef BSD +#define MAP_COPY MAP_PRIVATE +#define MAP_FILE 0 +#define MAP_ANON 0 +#endif +#include +#include +#include +#include +#if __STDC__ +#include +#else +#include +#endif + +#include "ld.h" + +#ifndef BSD /* Need do better than this */ +#define NEED_DEV_ZERO 1 +#endif + +/* + * Loader private data, hung off link_map->lm_lpd + */ +struct lm_private { + int lpd_version; + struct link_map *lpd_parent; +#ifdef SUN_COMPAT + long lpd_offset; /* Correction for Sun main programs */ +#endif +}; + +#ifdef SUN_COMPAT +#define LM_OFFSET(lmp) (((struct lm_private *)((lmp)->lm_lpd))->lpd_offset) +#else +#define LM_OFFSET(lmp) (0) +#endif + +/* Base address for link_dynamic_2 entries */ +#define LM_LDBASE(lmp) (lmp->lm_addr + LM_OFFSET(lmp)) + +/* Start of text segment */ +#define LM_TXTADDR(lmp) (lmp->lm_addr == (caddr_t)0 ? PAGSIZ : 0) + +/* Start of run-time relocation_info */ +#define LM_REL(lmp) ((struct relocation_info *) \ + (lmp->lm_addr + LM_OFFSET(lmp) + LD_REL((lmp)->lm_ld))) + +/* Start of symbols */ +#define LM_SYMBOL(lmp, i) ((struct nzlist *) \ + (lmp->lm_addr + LM_OFFSET(lmp) + LD_SYMBOL((lmp)->lm_ld) + \ + i * (LD_VERSION_NZLIST_P(lmp->lm_ld->ld_version) ? \ + sizeof(struct nzlist) : sizeof(struct nlist)))) + +/* Start of hash table */ +#define LM_HASH(lmp) ((struct rrs_hash *) \ + (lmp->lm_addr + LM_OFFSET(lmp) + LD_HASH((lmp)->lm_ld))) + +/* Start of strings */ +#define LM_STRINGS(lmp) ((char *) \ + (lmp->lm_addr + LM_OFFSET(lmp) + LD_STRINGS((lmp)->lm_ld))) + +/* End of text */ +#define LM_ETEXT(lmp) ((char *) \ + (lmp->lm_addr + LM_TXTADDR(lmp) + LD_TEXTSZ((lmp)->lm_ld))) + +/* PLT is in data segment, so don't use LM_OFFSET here */ +#define LM_PLT(lmp) ((jmpslot_t *) \ + (lmp->lm_addr + LD_PLT((lmp)->lm_ld))) + +/* Parent of link map */ +#define LM_PARENT(lmp) (((struct lm_private *)((lmp)->lm_lpd))->lpd_parent) + +char **environ; +int errno; +uid_t uid, euid; +gid_t gid, egid; +int careful; + +struct link_map *link_map_head, *main_map; +struct link_map **link_map_tail = &link_map_head; +struct rt_symbol *rt_symbol_head; + +static int dlopen(), dlclose(), dlsym(); + +static struct ld_entry ld_entry = { + dlopen, dlclose, dlsym +}; + +static void xprintf __P((char *, ...)); +static void init_brk __P((void)); +static void load_maps __P((struct crt_ldso *)); +static void map_object __P((struct link_object *, struct link_map *)); +static void alloc_link_map __P(( char *, struct link_object *, + struct link_map *, caddr_t, + struct link_dynamic *)); +static void check_text_reloc __P(( struct relocation_info *, + struct link_map *, + caddr_t)); +static void reloc_maps __P((void)); +static void reloc_copy __P((void)); +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 link_map **)); +static struct rt_symbol *lookup_rts __P((char *)); +static struct rt_symbol *enter_rts __P((char *, long, int, caddr_t, long)); + +#include "md-static-funcs.c" + +/* + * Called from assembler stub that has set up crtp (passed from crt0) + * and dp (our __DYNAMIC). + */ +void +rtld(version, crtp, dp) +int version; +struct crt_ldso *crtp; +struct link_dynamic *dp; +{ + int n; + int nreloc; /* # of ld.so relocations */ + struct relocation_info *reloc; + char **envp; + + /* Check version */ + if (version != CRT_VERSION_BSD && version != CRT_VERSION_SUN) + return; + + /* Fixup __DYNAMIC structure */ + (long)dp->ld_un.ld_2 += crtp->crt_ba; + + /* Be careful not to use .div routine from library */ + for ( nreloc = 0, n = LD_RELSZ(dp); + n > 0; + n -= sizeof(struct relocation_info) ) nreloc++; + + + /* Relocate ourselves */ + for ( reloc = (struct relocation_info *) + (dp->ld_un.ld_2->ld_rel + 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"; + + /* 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"); + unsetenv("LD_RUN_PATH"); /* In case we ever implement this */ + } + + /* Setup directory search */ + std_search_dirs(getenv("LD_LIBRARY_PATH")); + + /* Load required objects into the process address space */ + load_maps(crtp); + + /* Relocate all loaded objects according to their RRS segments */ + reloc_maps(); + reloc_copy(); + + /* Fill in some field in main's __DYNAMIC structure */ + crtp->crt_dp->ld_entry = &ld_entry; + crtp->crt_dp->ldd->ldd_cp = rt_symbol_head; +} + + +static void +load_maps(crtp) +struct crt_ldso *crtp; +{ + struct link_map *lmp; + int tracing = (int)getenv("LD_TRACE_LOADED_OBJECTS"); + + /* Handle LD_PRELOAD's here */ + + /* Make an entry for the main program */ + alloc_link_map("main", (struct link_object *)0, (struct link_map *)0, + (caddr_t)0, crtp->crt_dp); + + for (lmp = link_map_head; lmp; lmp = lmp->lm_next) { + struct link_object *lop; + long next = 0; + + if (lmp->lm_ld) + next = LD_NEED(lmp->lm_ld); + + while (next) { + lop = (struct link_object *) (LM_LDBASE(lmp) + next); + map_object(lop, lmp); + next = lop->lo_next; + } + } + + if (! tracing) + return; + + for (lmp = link_map_head; lmp; lmp = lmp->lm_next) { + struct link_object *lop; + char *name, *path; + + if ((lop = lmp->lm_lop) == NULL) + continue; + + name = lop->lo_name + LM_LDBASE(LM_PARENT(lmp)); + + if ((path = lmp->lm_name) == NULL) + path = "not found"; + + if (lop->lo_library) + printf("\t-l%s.%d => %s\n", name, lop->lo_major, path); + else + printf("\t%s => %s\n", name, path); + } + + _exit(0); +} + +/* + * Allocate a new link map for an shared object NAME loaded at ADDR as a + * result of the presence of link object LOP in the link map PARENT. + */ +static void +alloc_link_map(name, lop, parent, addr, dp) +char *name; +struct link_map *parent; +struct link_object *lop; +caddr_t addr; +struct link_dynamic *dp; +{ + struct link_map *lmp; + struct lm_private *lmpp; + + lmpp = (struct lm_private *)xmalloc(sizeof(struct lm_private)); + lmp = (struct link_map *)xmalloc(sizeof(struct link_map)); + lmp->lm_next = NULL; + *link_map_tail = lmp; + link_map_tail = &lmp->lm_next; + + lmp->lm_addr = addr; + lmp->lm_name = name; + lmp->lm_lop = lop; + lmp->lm_ld = dp; + lmp->lm_lpd = (caddr_t)lmpp; + +/*XXX*/ if (addr == 0) main_map = lmp; + + lmpp->lpd_parent = parent; + +#ifdef SUN_COMPAT + lmpp->lpd_offset = + (addr == 0 && dp->ld_version == LD_VERSION_SUN) ? PAGSIZ : 0; +#endif +} + +/* + * Map object identified by link object LOP which was found + * in link map LMP. + */ +static void +map_object(lop, lmp) +struct link_object *lop; +struct link_map *lmp; +{ + struct link_dynamic *dp; + char *path, *name = (char *)(lop->lo_name + LM_LDBASE(lmp)); + int fd; + caddr_t addr; + struct exec hdr; + int usehints = 0; + + if (lop->lo_library) { + usehints = 1; +again: + path = rtfindlib(name, lop->lo_major, lop->lo_minor, &usehints); + if (path == NULL) + fatal("Cannot find lib%s.so.%d.%d\n", + name, lop->lo_major, lop->lo_minor); + } else { + path = name; + } + + fd = open(path, O_RDONLY, 0); + if (fd == -1) { + if (usehints) { + usehints = 0; + goto again; + } + fatal("%s not found", path); + } + + if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) { + fatal("%s: Cannot read exec header", path); + } + + if (N_BADMAG(hdr)) + fatal("%s: Incorrect format", path); + + if ((addr = mmap(0, hdr.a_text + hdr.a_data, + PROT_READ|PROT_EXEC, + MAP_FILE|MAP_COPY, fd, 0)) == (caddr_t)-1) + fatal("Cannot map %s text\n", path); + + if (mmap(addr + hdr.a_text, hdr.a_data, + PROT_READ|PROT_WRITE|PROT_EXEC, + MAP_FILE|MAP_FIXED|MAP_COPY, + fd, hdr.a_text) == (caddr_t)-1) + fatal("Cannot map %s data", path); + + close(fd); + + fd = -1; +#ifdef NEED_DEV_ZERO + if ((fd = open("/dev/zero", O_RDWR, 0)) == -1) + perror("/dev/zero"); +#endif + if (hdr.a_bss && mmap(addr + hdr.a_text + hdr.a_data, hdr.a_bss, + PROT_READ|PROT_WRITE|PROT_EXEC, + MAP_ANON|MAP_FIXED|MAP_COPY, + fd, hdr.a_text + hdr.a_data) == (caddr_t)-1) + fatal("Cannot map %s bss", path); + +#ifdef NEED_DEV_ZERO + close(fd); +#endif + + /* Assume _DYNAMIC is the first data item */ + dp = (struct link_dynamic *)(addr+hdr.a_text); + + /* Fixup __DYNAMIC structure */ + (long)dp->ld_un.ld_2 += (long)addr; + + alloc_link_map(path, lop, lmp, addr, dp); + +} + +static void +reloc_maps() +{ + struct link_map *lmp; + + for (lmp = link_map_head; lmp; lmp = lmp->lm_next) { + + struct link_dynamic *dp = lmp->lm_ld; + struct relocation_info *r = LM_REL(lmp); + struct relocation_info *rend = r + LD_RELSZ(dp)/sizeof(*r); + + if (LD_PLTSZ(dp)) + md_fix_jmpslot(LM_PLT(lmp), + (long)LM_PLT(lmp), (long)binder_entry); + + for (; r < rend; r++) { + char *sym; + caddr_t addr = lmp->lm_addr + r->r_address; + + check_text_reloc(r, lmp, addr); + + if (RELOC_EXTERN_P(r)) { + struct link_map *src_map; + struct nzlist *np; + long relocation = md_get_addend(r, addr); + + if (RELOC_LAZY_P(r)) + continue; + + sym = LM_STRINGS(lmp) + + LM_SYMBOL(lmp,RELOC_SYMBOL(r))->nz_strx; + + np = lookup(sym, &src_map); + if (np == NULL) + fatal("Undefined symbol in %s: %s\n", + lmp->lm_name, sym); + + /* + * 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 += np->nz_value; + if (src_map) + relocation += (long)src_map->lm_addr; + + if (RELOC_PCREL_P(r)) + relocation -= (long)lmp->lm_addr; + + if (RELOC_COPY_P(r) && src_map) { +#if DEBUG +xprintf("RELOCATE(%s) copy: from %s at %#x(%#x+%#x) to %s at %#x, reloc = %#x, size %d\n", +lmp->lm_name, src_map->lm_name, src_map->lm_addr + np->nz_value, +src_map->lm_addr, np->nz_value, sym, addr, relocation, np->nz_size); +#endif + (void)enter_rts(sym, + (long)addr, + N_DATA + N_EXT, + src_map->lm_addr + np->nz_value, + np->nz_size); + continue; + } +#if DEBUG +xprintf("RELOCATE(%s) external: %s at %#x, reloc = %#x\n", lmp->lm_name, sym, addr, relocation); +#endif + md_relocate(r, relocation, addr, 0); + + } else { +#if DEBUG +xprintf("RELOCATE(%s) internal at %#x, reloc = %#x\n", lmp->lm_name, addr, md_get_rt_segment_addend(r,addr)); +#endif + md_relocate(r, +#ifdef SUN_COMPAT + md_get_rt_segment_addend(r, addr) +#else + md_get_addend(r, addr) +#endif + + (long)lmp->lm_addr, addr, 0); + } + + } + + } +} + +static void +reloc_copy() +{ + struct rt_symbol *rtsp; + + for (rtsp = rt_symbol_head; rtsp; rtsp = rtsp->rt_next) + if (rtsp->rt_sp->nz_type == N_DATA + N_EXT) { +#ifdef DEBUG +xprintf("reloc_copy: from %#x to %#x, size %d\n", +rtsp->rt_srcaddr, rtsp->rt_sp->nz_value, rtsp->rt_sp->nz_size); +#endif + bcopy(rtsp->rt_srcaddr, (caddr_t)rtsp->rt_sp->nz_value, + rtsp->rt_sp->nz_size); + } +} + +static void +check_text_reloc(r, lmp, addr) +struct relocation_info *r; +struct link_map *lmp; +caddr_t addr; +{ + char *sym; + + if (addr >= LM_ETEXT(lmp)) + return; + + if (RELOC_EXTERN_P(r)) + sym = LM_STRINGS(lmp) + + LM_SYMBOL(lmp, RELOC_SYMBOL(r))->nz_strx; + else + sym = ""; + +#ifdef DEBUG + fprintf(stderr, "ld.so: warning: non pure code in %s at %x (%s)\n", + lmp->lm_name, r->r_address, sym); +#endif + + if (mprotect( lmp->lm_addr + LM_TXTADDR(lmp), + LD_TEXTSZ(lmp->lm_ld), + PROT_READ|PROT_WRITE|PROT_EXEC) == -1) { + + perror("mprotect"), + fatal("Cannot enable writes to %s\n", lmp->lm_name); + } + + lmp->lm_rwt = 1; +} + +static struct nzlist * +lookup(name, src_map) +char *name; +struct link_map **src_map; +{ + long common_size = 0; + struct link_map *lmp; + struct rt_symbol *rtsp; + + *src_map = NULL; + + if ((rtsp = lookup_rts(name)) != NULL) + return rtsp->rt_sp; + + /* + * Search all maps for a definition of NAME + */ + for (lmp = link_map_head; lmp; lmp = lmp->lm_next) { + int buckets = LD_BUCKETS(lmp->lm_ld); + long hashval = 0; + struct rrs_hash *hp; + char *cp; + struct nzlist *np; + + /* + * Compute bucket in which the symbol might be found. + */ + for (cp = name; *cp; cp++) + hashval = (hashval << 1) + *cp; + + hashval = (hashval & 0x7fffffff) % buckets; + + hp = LM_HASH(lmp) + hashval; + if (hp->rh_symbolnum == -1) + /* Nothing in this bucket */ + continue; + + while (hp) { + np = LM_SYMBOL(lmp, hp->rh_symbolnum); + cp = LM_STRINGS(lmp) + np->nz_strx; + if (strcmp(cp, name) == 0) + break; + if (hp->rh_next == 0) + hp = NULL; + else + hp = LM_HASH(lmp) + 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_value == 0) + /* It's not a definition */ + continue; + + if (np->nz_type == N_UNDF+N_EXT && np->nz_value != 0) { + /* It's a common, note value and continue search */ + if (common_size < np->nz_value) + common_size = np->nz_value; + continue; + } + + *src_map = lmp; + 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); + +#if DEBUG +xprintf("Allocating common: %s size %d at %#x\n", name, common_size, rtsp->rt_sp->nz_value); +#endif + + return rtsp->rt_sp; +} + + +/* + * This routine is called from the jumptable to resolve + * procedure calls to shared objects. + */ +long +binder(jsp) +jmpslot_t *jsp; +{ + struct link_map *lmp, *src_map; + long addr; + char *sym; + struct nzlist *np; + int index; + + /* + * Find the PLT map that contains JSP. + */ + for (lmp = link_map_head; lmp; lmp = lmp->lm_next) { + if (LM_PLT(lmp) < jsp && + jsp < LM_PLT(lmp) + LD_PLTSZ(lmp->lm_ld)/sizeof(*jsp)) + break; + } + + if (lmp == NULL) + fatal("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(lmp) + + LM_SYMBOL(lmp,RELOC_SYMBOL(&LM_REL(lmp)[index]))->nz_strx; + + np = lookup(sym, &src_map); + if (np == NULL) + fatal("Undefined symbol \"%s\" called from %s at %#x", sym, + lmp->lm_name, jsp); + + /* Fixup jmpslot so future calls transfer directly to target */ + addr = np->nz_value; + if (src_map) + addr += (long)src_map->lm_addr; + + md_fix_jmpslot(jsp, (long)jsp, addr); + +#if DEBUG +xprintf(" BINDER: %s located at = %#x in %s\n", sym, addr, src_map->lm_name); +#endif + return addr; +} + + +/* + * 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 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 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) + char *name; + long value; + int type; + caddr_t srcaddr; + long size; +{ + 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) + ; + + /* 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_link = NULL; + + /* Link onto linear list as well */ + rtsp->rt_next = rt_symbol_head; + rt_symbol_head = rtsp; + + *rpp = rtsp; + + return rtsp; +} + +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() +{ + caddr_t addr; + long msize; + int fd; + + if ((fd = open(_PATH_LD_HINTS, O_RDONLY, 0)) == -1) { + hheader = (struct hints_header *)-1; + return; + } + + msize = PAGSIZ; + addr = mmap(0, msize, PROT_READ, MAP_FILE|MAP_COPY, fd, 0); + + if (addr == (caddr_t)-1) { + hheader = (struct hints_header *)-1; + return; + } + + hheader = (struct hints_header *)addr; + if (HH_BADMAG(*hheader)) { + munmap(addr, msize); + hheader = (struct hints_header *)-1; + return; + } + + if (hheader->hh_version != LD_HINTS_VERSION_1) { + munmap(addr, msize); + hheader = (struct hints_header *)-1; + return; + } + + if (hheader->hh_ehints > msize) { + if (mmap(addr+msize, hheader->hh_ehints - msize, + PROT_READ, MAP_FILE|MAP_COPY|MAP_FIXED, + fd, msize) != (caddr_t)(addr+msize)) { + + munmap((caddr_t)hheader, msize); + hheader = (struct hints_header *)-1; + return; + } + } + close(fd); + + hbuckets = (struct hints_bucket *)(addr + hheader->hh_hashtab); + hstrtab = (char *)(addr + hheader->hh_strtab); +} + +int +hinthash(cp, vmajor, vminor) +char *cp; +int vmajor, vminor; +{ + int k = 0; + + while (*cp) + k = (((k << 1) + (k >> 14)) ^ (*cp++)) & 0x3fff; + + k = (((k << 1) + (k >> 14)) ^ (vmajor*257)) & 0x3fff; + k = (((k << 1) + (k >> 14)) ^ (vminor*167)) & 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, minor) % hheader->hh_nbucket); + + while (1) { + /* Sanity check */ + if (bp->hi_namex >= hheader->hh_strtab_sz) { + fprintf(stderr, "Bad name index: %#x\n", bp->hi_namex); + break; + } + if (bp->hi_pathx >= hheader->hh_strtab_sz) { + fprintf(stderr, "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 *hint; + char *cp, *ld_path = getenv("LD_LIBRARY_PATH"); + + if (hheader == NULL) + maphints(); + + if (!HINTS_VALID || !(*usehints)) { + *usehints = 0; + return (char *)findshlib(name, &major, &minor); + } + + if (ld_path != NULL) { + /* Prefer paths from LD_LIBRARY_PATH */ + while ((cp = strtok(ld_path, ":")) != NULL) { + + ld_path = NULL; + hint = findhint(name, major, minor, cp); + if (hint) + return hint; + } + } else { + /* No LD_LIBRARY_PATH, check default */ + hint = findhint(name, major, minor, NULL); + if (hint) + return hint; + } + + /* No hints available for name */ + *usehints = 0; + return (char *)findshlib(name, &major, &minor); +} + +static int +dlopen(name, mode) +char *name; +int mode; +{ + xprintf("dlopen(%s, %x)\n", name, mode); + return -1; +} + +static int +dlclose(fd) +int fd; +{ + xprintf("dlclose(%d)\n", fd); + return -1; +} + +static int +dlsym(fd, sym) +int fd; +char *sym; +{ + xprintf("dlsym(%d, %s)\n", fd, sym); + return 0; +} + +/* + * Private heap functions. + */ + +static caddr_t curbrk; + +static void +init_brk() +{ + struct rlimit rlim; + char *cp, **cpp = environ; + + if (getrlimit(RLIMIT_STACK, &rlim) < 0) { + xprintf("ld.so: brk: getrlimit failure\n"); + _exit(1); + } + + /* + * Walk to the top of stack + */ + if (*cpp) { + while (*cpp) cpp++; + cp = *--cpp; + while (*cp) cp++; + } else + cp = (char *)&cp; + + curbrk = (caddr_t) + (((long)(cp - 1 - rlim.rlim_cur) + PAGSIZ) & ~(PAGSIZ - 1)); +} + +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); +} + +caddr_t +sbrk(incr) +int incr; +{ + int fd = -1; + caddr_t oldbrk; + + if (curbrk == 0) + init_brk(); + +#if DEBUG +xprintf("sbrk: incr = %#x, curbrk = %#x\n", incr, curbrk); +#endif + if (incr == 0) + return curbrk; + + incr = (incr + PAGSIZ - 1) & ~(PAGSIZ - 1); + +#ifdef NEED_DEV_ZERO + fd = open("/dev/zero", O_RDWR, 0); + if (fd == -1) + perror("/dev/zero"); +#endif + + if (mmap(curbrk, incr, + PROT_READ|PROT_WRITE, + MAP_ANON|MAP_FIXED|MAP_COPY, fd, 0) == (caddr_t)-1) { + perror("Cannot map anonymous memory"); + } + +#ifdef NEED_DEV_ZERO + close(fd); +#endif + + oldbrk = curbrk; + curbrk += incr; + + return oldbrk; +} diff --git a/libexec/rtld-aout/shlib.c b/libexec/rtld-aout/shlib.c new file mode 100644 index 0000000..4be8354 --- /dev/null +++ b/libexec/rtld-aout/shlib.c @@ -0,0 +1,203 @@ +/* + * $Id: shlib.c,v 1.3 1993/10/23 00:34:26 pk Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ld.h" + +/* + * Standard directories to search for files specified by -l. + */ +#ifndef STANDARD_SEARCH_DIRS +#define STANDARD_SEARCH_DIRS "/usr/lib", "/usr/local/lib" +#endif + +char *standard_search_dirs[] = { + STANDARD_SEARCH_DIRS +}; + +int n_search_dirs; + +void +add_search_dir(name) + char *name; +{ + n_search_dirs++; + search_dirs = (char **)xrealloc(search_dirs, + n_search_dirs * sizeof(char *)); + search_dirs[n_search_dirs - 1] = strdup(name); +} + +void +std_search_dirs(paths) +char *paths; +{ + char *cp; + int i, n; + + if (paths != NULL) + /* Add search directories from `paths' */ + while ((cp = strtok(paths, ":")) != NULL) { + paths = NULL; + add_search_dir(cp); + } + + /* Append standard search directories */ + n = sizeof standard_search_dirs / sizeof standard_search_dirs[0]; + for (i = 0; i < n; i++) + add_search_dir(standard_search_dirs[i]); +} + +/* + * Return true if CP points to a valid dewey number. + * Decode and leave the result in the array DEWEY. + * Return the number of decoded entries in DEWEY. + */ + +int +getdewey(dewey, cp) +int dewey[]; +char *cp; +{ + int i, n; + + for (n = 0, i = 0; i < MAXDEWEY; i++) { + if (*cp == '\0') + break; + + if (*cp == '.') cp++; + if (!isdigit(*cp)) + return 0; + + dewey[n++] = strtol(cp, &cp, 10); + } + + return n; +} + +/* + * Compare two dewey arrays. + * Return -1 if `d1' represents a smaller value than `d2'. + * Return 1 if `d1' represents a greater value than `d2'. + * Return 0 if equal. + */ +int +cmpndewey(d1, n1, d2, n2) +int d1[], d2[]; +int n1, n2; +{ + int i; + + for (i = 0; i < n1 && i < n2; i++) { + if (d1[i] < d2[i]) + return -1; + if (d1[i] > d2[i]) + return 1; + } + + if (n1 == n2) + return 0; + + if (i == n1) + return -1; + + if (i == n2) + return 1; +} + +/* + * Search directories for a shared library matching the given + * major and minor version numbers. + * + * MAJOR == -1 && MINOR == -1 --> find highest version + * MAJOR != -1 && MINOR == -1 --> find highest minor version + * MAJOR == -1 && MINOR != -1 --> invalid + * MAJOR != -1 && MINOR != -1 --> find highest micro version + */ + +/* Not interested in devices right now... */ +#undef major +#undef minor + +char * +findshlib(name, majorp, minorp) +char *name; +int *majorp, *minorp; +{ + int dewey[MAXDEWEY]; + int ndewey; + int tmp[MAXDEWEY]; + int i; + int len; + char *lname, *path = NULL; + int major = *majorp, minor = *minorp; + + len = strlen(name); + lname = (char *)alloca(len + sizeof("lib")); + sprintf(lname, "lib%s", name); + len += 3; + + ndewey = 0; + + for (i = 0; i < n_search_dirs; i++) { + DIR *dd = opendir(search_dirs[i]); + struct dirent *dp; + + if (dd == NULL) + continue; + + while ((dp = readdir(dd)) != NULL) { + int n, j, might_take_it = 0; + + if (dp->d_namlen < len + 4) + continue; + if (strncmp(dp->d_name, lname, len) != 0) + continue; + if (strncmp(dp->d_name+len, ".so.", 4) != 0) + continue; + + if ((n = getdewey(tmp, dp->d_name+len+4)) == 0) + continue; + + if (major == -1 && minor == -1) { + might_take_it = 1; + } else if (major != -1 && minor == -1) { + if (tmp[0] == major) + might_take_it = 1; + } else if (major != -1 && minor != -1) { + if (tmp[0] == major) + if (n == 1 || tmp[1] >= minor) + might_take_it = 1; + } + + if (!might_take_it) + continue; + + if (cmpndewey(tmp, n, dewey, ndewey) <= 0) + continue; + + /* We have a better version */ + if (path) + free(path); + path = concat(search_dirs[i], "/", dp->d_name); + bcopy(tmp, dewey, sizeof(dewey)); + ndewey = n; + *majorp = dewey[0]; + *minorp = dewey[1]; + } + closedir(dd); + } + + return path; +} -- cgit v1.1