libexec/ld.elf_so/reloc.c

   1 /*      $NetBSD: reloc.c,v 1.103 2010/12/24 12:41:43 skrll Exp $         */
   2
   3 /*
   4  * Copyright 1996 John D. Polstra.
   5  * Copyright 1996 Matt Thomas <matt@3am-software.com>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by John Polstra.
  19  * 4. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * Dynamic linker for ELF.
  36  *
  37  * John Polstra <jdp@polstra.com>.
  38  */
  39
  40 #include <sys/cdefs.h>
  41 #ifndef lint
  42 __RCSID("$NetBSD: reloc.c,v 1.103 2010/12/24 12:41:43 skrll Exp $");
  43 #endif /* not lint */
  44
  45 #include <err.h>
  46 #include <errno.h>
  47 #include <fcntl.h>
  48 #include <stdarg.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53 #include <sys/types.h>
  54 #include <sys/mman.h>
  55 #include <sys/bitops.h>
  56 #include <dirent.h>
  57
  58 #include "debug.h"
  59 #include "rtld.h"
  60
  61 #ifndef RTLD_INHIBIT_COPY_RELOCS
  62 static int _rtld_do_copy_relocation(const Obj_Entry *, const Elf_Rela *);
  63
  64 static int
  65 _rtld_do_copy_relocation(const Obj_Entry *dstobj, const Elf_Rela *rela)
  66 {
  67         void           *dstaddr = (void *)(dstobj->relocbase + rela->r_offset);
  68         const Elf_Sym  *dstsym = dstobj->symtab + ELF_R_SYM(rela->r_info);
  69         const char     *name = dstobj->strtab + dstsym->st_name;
  70         unsigned long   hash = _rtld_elf_hash(name);
  71         size_t          size = dstsym->st_size;
  72         const void     *srcaddr;
  73         const Elf_Sym  *srcsym = NULL;
  74         Obj_Entry      *srcobj;
  75
  76         for (srcobj = dstobj->next; srcobj != NULL; srcobj = srcobj->next)
  77                 if ((srcsym = _rtld_symlook_obj(name, hash, srcobj, false)) != NULL)
  78                         break;
  79
  80         if (srcobj == NULL) {
  81                 _rtld_error("Undefined symbol \"%s\" referenced from COPY"
  82                     " relocation in %s", name, dstobj->path);
  83                 return (-1);
  84         }
  85         srcaddr = (const void *)(srcobj->relocbase + srcsym->st_value);
  86         (void)memcpy(dstaddr, srcaddr, size);
  87         rdbg(("COPY %s %s %s --> src=%p dst=%p size %ld",
  88             dstobj->path, srcobj->path, name, srcaddr,
  89             (void *)dstaddr, (long)size));
  90         return (0);
  91 }
  92 #endif /* RTLD_INHIBIT_COPY_RELOCS */
  93
  94
  95 /*
  96  * Process the special R_xxx_COPY relocations in the main program.  These
  97  * copy data from a shared object into a region in the main program's BSS
  98  * segment.
  99  *
 100  * Returns 0 on success, -1 on failure.
 101  */
 102 int
 103 _rtld_do_copy_relocations(const Obj_Entry *dstobj)
 104 {
 105 #ifndef RTLD_INHIBIT_COPY_RELOCS
 106
 107         /* COPY relocations are invalid elsewhere */
 108         assert(!dstobj->isdynamic);
 109
 110         if (dstobj->rel != NULL) {
 111                 const Elf_Rel  *rel;
 112                 for (rel = dstobj->rel; rel < dstobj->rellim; ++rel) {
 113                         if (ELF_R_TYPE(rel->r_info) == R_TYPE(COPY)) {
 114                                 Elf_Rela        ourrela;
 115                                 ourrela.r_info = rel->r_info;
 116                                 ourrela.r_offset = rel->r_offset;
 117                                 ourrela.r_addend = 0;
 118                                 if (_rtld_do_copy_relocation(dstobj,
 119                                     &ourrela) < 0)
 120                                         return (-1);
 121                         }
 122                 }
 123         }
 124         if (dstobj->rela != NULL) {
 125                 const Elf_Rela *rela;
 126                 for (rela = dstobj->rela; rela < dstobj->relalim; ++rela) {
 127                         if (ELF_R_TYPE(rela->r_info) == R_TYPE(COPY)) {
 128                                 if (_rtld_do_copy_relocation(dstobj, rela) < 0)
 129                                         return (-1);
 130                         }
 131                 }
 132         }
 133 #endif /* RTLD_INHIBIT_COPY_RELOCS */
 134
 135         return (0);
 136 }
 137
 138 /*
 139  * Relocate newly-loaded shared objects.  The argument is a pointer to
 140  * the Obj_Entry for the first such object.  All objects from the first
 141  * to the end of the list of objects are relocated.  Returns 0 on success,
 142  * or -1 on failure.
 143  */
 144 int
 145 _rtld_relocate_objects(Obj_Entry *first, bool bind_now)
 146 {
 147         Obj_Entry *obj;
 148         int ok = 1;
 149
 150         for (obj = first; obj != NULL; obj = obj->next) {
 151                 if (obj->nbuckets == 0 || obj->nchains == 0 ||
 152                     obj->buckets == NULL || obj->symtab == NULL ||
 153                     obj->strtab == NULL) {
 154                         _rtld_error("%s: Shared object has no run-time"
 155                             " symbol table", obj->path);
 156                         return -1;
 157                 }
 158                 if (obj->nbuckets == UINT32_MAX) {
 159                         _rtld_error("%s: Symbol table too large", obj->path);
 160                         return -1;
 161                 }
 162                 rdbg((" relocating %s (%ld/%ld rel/rela, %ld/%ld plt rel/rela)",
 163                     obj->path,
 164                     (long)(obj->rellim - obj->rel),
 165                     (long)(obj->relalim - obj->rela),
 166                     (long)(obj->pltrellim - obj->pltrel),
 167                     (long)(obj->pltrelalim - obj->pltrela)));
 168
 169 #ifndef __minix
 170                 if (obj->textrel) {
 171                         /*
 172                          * There are relocations to the write-protected text
 173                          * segment.
 174                          */
 175                         if (mprotect(obj->mapbase, obj->textsize,
 176                                 PROT_READ | PROT_WRITE | PROT_EXEC) == -1) {
 177                                 _rtld_error("%s: Cannot write-enable text "
 178                                     "segment: %s", obj->path, xstrerror(errno));
 179                                 return -1;
 180                         }
 181                 }
 182 #endif
 183
 184                 dbg(("doing non-PLT relocations"));
 185                 if (_rtld_relocate_nonplt_objects(obj) < 0)
 186                         ok = 0;
 187
 188 #ifndef __minix
 189                 if (obj->textrel) {     /* Re-protected the text segment. */
 190                         if (mprotect(obj->mapbase, obj->textsize,
 191                                      PROT_READ | PROT_EXEC) == -1) {
 192                                 _rtld_error("%s: Cannot write-protect text "
 193                                     "segment: %s", obj->path, xstrerror(errno));
 194                                 return -1;
 195                         }
 196                 }
 197 #endif
 198
 199                 dbg(("doing lazy PLT binding"));
 200                 if (_rtld_relocate_plt_lazy(obj) < 0)
 201                         ok = 0;
 202 #if defined(__hppa__)
 203                 bind_now = 1;
 204 #endif
 205                 if (obj->z_now || bind_now) {
 206                         dbg(("doing immediate PLT binding"));
 207                         if (_rtld_relocate_plt_objects(obj) < 0)
 208                                 ok = 0;
 209                 }
 210                 if (!ok)
 211                         return -1;
 212
 213                 /* Set some sanity-checking numbers in the Obj_Entry. */
 214                 obj->magic = RTLD_MAGIC;
 215                 obj->version = RTLD_VERSION;
 216
 217                 /* Fill in the dynamic linker entry points. */
 218                 obj->dlopen = dlopen;
 219                 obj->dlsym = dlsym;
 220                 obj->dlerror = dlerror;
 221                 obj->dlclose = dlclose;
 222                 obj->dladdr = dladdr;
 223
 224                 dbg(("fixing up PLTGOT"));
 225                 /* Set the special PLTGOT entries. */
 226                 if (obj->pltgot != NULL)
 227                         _rtld_setup_pltgot(obj);
 228         }
 229
 230         return 0;
 231 }