nsz Git - musl/blob - ldso/dlstart.c

   1 #include <stddef.h>
   2 #include "dynlink.h"
   3
   4 #ifndef START
   5 #define START "_dlstart"
   6 #endif
   7
   8 #include "crt_arch.h"
   9
  10 #ifndef GETFUNCSYM
  11 #define GETFUNCSYM(fp, sym, got) do { \
  12         __attribute__((__visibility__("hidden"))) void sym(); \
  13         static void (*static_func_ptr)() = sym; \
  14         __asm__ __volatile__ ( "" : "+m"(static_func_ptr) : : "memory"); \
  15         *(fp) = static_func_ptr; } while(0)
  16 #endif
  17
  18 __attribute__((__visibility__("hidden")))
  19 void _dlstart_c(size_t *sp, size_t *dynv)
  20 {
  21         size_t i, aux[AUX_CNT], dyn[DYN_CNT];
  22         size_t *rel, rel_size, base;
  23
  24         int argc = *sp;
  25         char **argv = (void *)(sp+1);
  26
  27         for (i=argc+1; argv[i]; i++);
  28         size_t *auxv = (void *)(argv+i+1);
  29
  30         for (i=0; i<AUX_CNT; i++) aux[i] = 0;
  31         for (i=0; auxv[i]; i+=2) if (auxv[i]<AUX_CNT)
  32                 aux[auxv[i]] = auxv[i+1];
  33
  34 #if DL_FDPIC
  35         struct fdpic_loadseg *segs, fakeseg;
  36         size_t j;
  37         if (dynv) {
  38                 /* crt_arch.h entry point asm is responsible for reserving
  39                  * space and moving the extra fdpic arguments to the stack
  40                  * vector where they are easily accessible from C. */
  41                 segs = ((struct fdpic_loadmap *)(sp[-1] ? sp[-1] : sp[-2]))->segs;
  42         } else {
  43                 /* If dynv is null, the entry point was started from loader
  44                  * that is not fdpic-aware. We can assume normal fixed-
  45                  * displacement ELF loading was performed, but when ldso was
  46                  * run as a command, finding the Ehdr is a heursitic: we
  47                  * have to assume Phdrs start in the first 4k of the file. */
  48                 base = aux[AT_BASE];
  49                 if (!base) base = aux[AT_PHDR] & -4096;
  50                 segs = &fakeseg;
  51                 segs[0].addr = base;
  52                 segs[0].p_vaddr = 0;
  53                 segs[0].p_memsz = -1;
  54                 Ehdr *eh = (void *)base;
  55                 Phdr *ph = (void *)(base + eh->e_phoff);
  56                 size_t phnum = eh->e_phnum;
  57                 size_t phent = eh->e_phentsize;
  58                 while (phnum-- && ph->p_type != PT_DYNAMIC)
  59                         ph = (void *)((size_t)ph + phent);
  60                 dynv = (void *)(base + ph->p_vaddr);
  61         }
  62 #endif
  63
  64         for (i=0; i<DYN_CNT; i++) dyn[i] = 0;
  65         for (i=0; dynv[i]; i+=2) if (dynv[i]<DYN_CNT)
  66                 dyn[dynv[i]] = dynv[i+1];
  67
  68 #if DL_FDPIC
  69         for (i=0; i<DYN_CNT; i++) {
  70                 if (i==DT_RELASZ || i==DT_RELSZ) continue;
  71                 if (!dyn[i]) continue;
  72                 for (j=0; dyn[i]-segs[j].p_vaddr >= segs[j].p_memsz; j++);
  73                 dyn[i] += segs[j].addr - segs[j].p_vaddr;
  74         }
  75         base = 0;
  76
  77         const Sym *syms = (void *)dyn[DT_SYMTAB];
  78
  79         rel = (void *)dyn[DT_RELA];
  80         rel_size = dyn[DT_RELASZ];
  81         for (; rel_size; rel+=3, rel_size-=3*sizeof(size_t)) {
  82                 if (!IS_RELATIVE(rel[1], syms)) continue;
  83                 for (j=0; rel[0]-segs[j].p_vaddr >= segs[j].p_memsz; j++);
  84                 size_t *rel_addr = (void *)
  85                         (rel[0] + segs[j].addr - segs[j].p_vaddr);
  86                 if (R_TYPE(rel[1]) == REL_FUNCDESC_VAL) {
  87                         *rel_addr += segs[rel_addr[1]].addr
  88                                 - segs[rel_addr[1]].p_vaddr
  89                                 + syms[R_SYM(rel[1])].st_value;
  90                         rel_addr[1] = dyn[DT_PLTGOT];
  91                 } else {
  92                         size_t val = syms[R_SYM(rel[1])].st_value;
  93                         for (j=0; val-segs[j].p_vaddr >= segs[j].p_memsz; j++);
  94                         *rel_addr = rel[2] + segs[j].addr - segs[j].p_vaddr + val;
  95                 }
  96         }
  97 #else
  98         /* If the dynamic linker is invoked as a command, its load
  99          * address is not available in the aux vector. Instead, compute
 100          * the load address as the difference between &_DYNAMIC and the
 101          * virtual address in the PT_DYNAMIC program header. */
 102         base = aux[AT_BASE];
 103         if (!base) {
 104                 size_t phnum = aux[AT_PHNUM];
 105                 size_t phentsize = aux[AT_PHENT];
 106                 Phdr *ph = (void *)aux[AT_PHDR];
 107                 for (i=phnum; i--; ph = (void *)((char *)ph + phentsize)) {
 108                         if (ph->p_type == PT_DYNAMIC) {
 109                                 base = (size_t)dynv - ph->p_vaddr;
 110                                 break;
 111                         }
 112                 }
 113         }
 114
 115         /* MIPS uses an ugly packed form for GOT relocations. Since we
 116          * can't make function calls yet and the code is tiny anyway,
 117          * it's simply inlined here. */
 118         if (NEED_MIPS_GOT_RELOCS) {
 119                 size_t local_cnt = 0;
 120                 size_t *got = (void *)(base + dyn[DT_PLTGOT]);
 121                 for (i=0; dynv[i]; i+=2) if (dynv[i]==DT_MIPS_LOCAL_GOTNO)
 122                         local_cnt = dynv[i+1];
 123                 for (i=0; i<local_cnt; i++) got[i] += base;
 124         }
 125
 126         rel = (void *)(base+dyn[DT_REL]);
 127         rel_size = dyn[DT_RELSZ];
 128         for (; rel_size; rel+=2, rel_size-=2*sizeof(size_t)) {
 129                 if (!IS_RELATIVE(rel[1], 0)) continue;
 130                 size_t *rel_addr = (void *)(base + rel[0]);
 131                 *rel_addr += base;
 132         }
 133
 134         rel = (void *)(base+dyn[DT_RELA]);
 135         rel_size = dyn[DT_RELASZ];
 136         for (; rel_size; rel+=3, rel_size-=3*sizeof(size_t)) {
 137                 if (!IS_RELATIVE(rel[1], 0)) continue;
 138                 size_t *rel_addr = (void *)(base + rel[0]);
 139                 *rel_addr = base + rel[2];
 140         }
 141 #endif
 142
 143         stage2_func dls2;
 144         GETFUNCSYM(&dls2, __dls2, base+dyn[DT_PLTGOT]);
 145         dls2((void *)base, sp);
 146 }