void _dl_boot_bind(const long sp, long *dl_data, Elf_Dyn *dynamicp) { struct elf_object dynld; /* Resolver data for the loader */ AuxInfo *auxstack; long *stack; Elf_Dyn *dynp; int n, argc; char **argv, **envp; long loff; /* * Scan argument and environment vectors. Find dynamic * data vector put after them. */ stack = (long *)sp; argc = *stack++; argv = (char **)stack; envp = &argv[argc + 1]; stack = (long *)envp; while (*stack++ != 0L) ; /* * Zero out dl_data. */ for (n = 0; n <= AUX_entry; n++) dl_data[n] = 0; /* * Dig out auxiliary data set up by exec call. Move all known * tags to an indexed local table for easy access. */ for (auxstack = (AuxInfo *)stack; auxstack->au_id != AUX_null; auxstack++) { if (auxstack->au_id > AUX_entry) continue; dl_data[auxstack->au_id] = auxstack->au_v; } loff = dl_data[AUX_base]; /* XXX assumes ld.so is linked at 0x0 */ /* * We need to do 'selfreloc' in case the code weren't * loaded at the address it was linked to. * * Scan the DYNAMIC section for the loader. * Cache the data for easier access. */ dynp = (Elf_Dyn *)((long)_DYNAMIC + loff); _dl_memset(dynld.Dyn.info, 0, sizeof(dynld.Dyn.info)); while (dynp != NULL && dynp->d_tag != DT_NULL) { if (dynp->d_tag < DT_NUM) dynld.Dyn.info[dynp->d_tag] = dynp->d_un.d_val; else if (dynp->d_tag >= DT_LOPROC && dynp->d_tag < DT_LOPROC + DT_PROCNUM) dynld.Dyn.info[dynp->d_tag - DT_LOPROC + DT_NUM] = dynp->d_un.d_val; if (dynp->d_tag == DT_TEXTREL) dynld.dyn.textrel = 1; dynp++; } /* * Do the 'bootstrap relocation'. This is really only needed if * the code was loaded at another location than it was linked to. * We don't do undefined symbols resolving (to difficult..) */ /* "relocate" dyn.X values if they represent addresses */ { int i, val; /* must be code, not pic data */ int table[20]; i = 0; table[i++] = DT_PLTGOT; table[i++] = DT_HASH; table[i++] = DT_STRTAB; table[i++] = DT_SYMTAB; table[i++] = DT_RELA; table[i++] = DT_INIT; table[i++] = DT_FINI; table[i++] = DT_REL; table[i++] = DT_JMPREL; /* other processors insert their extras here */ table[i++] = DT_NULL; for (i = 0; table[i] != DT_NULL; i++) { val = table[i]; if (val >= DT_LOPROC && val < DT_LOPROC + DT_PROCNUM) val = val - DT_LOPROC + DT_NUM; else if (val >= DT_NUM) continue; if (dynld.Dyn.info[val] != 0) dynld.Dyn.info[val] += loff; } } { u_int32_t rs; Elf_Rel *rp; int i; rp = (Elf_Rel *)(dynld.Dyn.info[DT_REL]); rs = dynld.dyn.relsz; for (i = 0; i < rs; i += sizeof (Elf_Rel)) { Elf_Addr *ra; const Elf_Sym *sp; sp = dynld.dyn.symtab; sp += ELF_R_SYM(rp->r_info); if (ELF_R_SYM(rp->r_info) && sp->st_value == 0) { #if 0 /* cannot printf in this function */ _dl_wrstderr("Dynamic loader failure: self bootstrapping impossible.\n"); _dl_wrstderr("Undefined symbol: "); _dl_wrstderr((char *)dynld.dyn.strtab + sp->st_name); #endif _dl_exit(5); } ra = (Elf_Addr *)(rp->r_offset + loff); RELOC_REL(rp, sp, ra, loff); rp++; } } for (n = 0; n < 2; n++) { unsigned long rs; Elf_RelA *rp; int i; switch (n) { case 0: rp = (Elf_RelA *)(dynld.Dyn.info[DT_JMPREL]); rs = dynld.dyn.pltrelsz; break; case 1: rp = (Elf_RelA *)(dynld.Dyn.info[DT_RELA]); rs = dynld.dyn.relasz; break; default: rp = NULL; rs = 0; } for (i = 0; i < rs; i += sizeof (Elf_RelA)) { Elf_Addr *ra; const Elf_Sym *sp; sp = dynld.dyn.symtab; sp += ELF_R_SYM(rp->r_info); if (ELF_R_SYM(rp->r_info) && sp->st_value == 0) { #if 0 _dl_wrstderr("Dynamic loader failure: self bootstrapping impossible.\n"); _dl_wrstderr("Undefined symbol: "); _dl_wrstderr((char *)dynld.dyn.strtab + sp->st_name); #endif _dl_exit(6); } ra = (Elf_Addr *)(rp->r_offset + loff); RELOC_RELA(rp, sp, ra, loff, dynld.dyn.pltgot); rp++; } } RELOC_GOT(&dynld, loff); /* * we have been fully relocated here, so most things no longer * need the loff adjustment */ }
/* We are running on the process being loaded */ unsigned int __ldep(struct init_data_dl *initd) { unsigned int rsize, n; Elf32_Rel *rel; Elf32_Rela *rela; Elf32_Sym *sym; dyncache dync; int i; /******************************************************/ /* LD Relocation */ /******************************************************/ /* We need to relocate ourselves. First add the offset to the dynamic section pointers. */ Elf32_Dyn *dyn = (Elf32_Dyn *)(initd->ld_dynamic); for(i = 0; i < 24; i++) dync.data[i] = 0; i = 0; while(dyn[i].d_tag != DT_NULL) { if(dyn[i].d_tag < 24 || dyn[i].d_tag == 30) { switch(dyn[i].d_tag) { case DT_PLTGOT: case DT_HASH: case DT_STRTAB: case DT_SYMTAB: case DT_RELA: case DT_INIT: case DT_FINI: case DT_REL: case DT_DEBUG: case DT_JMPREL: dync.data[dyn[i].d_tag] = (unsigned int)dyn[i].d_un.d_ptr + (unsigned int)initd->ld_start; break; case DT_SYMBOLIC: dync.data[DT_FLAGS] |= DF_SYMBOLIC; break; case DT_FLAGS: dync.data[25] |= dyn[i].d_un.d_val; break; default: dync.data[dyn[i].d_tag] = dyn[i].d_un.d_val; } } i++; } // relocate rel relocation section rel = (Elf32_Rel*)dync.data[DT_REL]; rsize = dync.data[DT_RELSZ]; n = 0; do { for (i = 0; i < rsize; i += sizeof (Elf32_Rel)) { sym = (Elf32_Sym*)(dync.data[DT_SYMTAB] + sizeof(Elf32_Sym) * ELF32_R_SYM(rel->r_info)); RELOC_REL(rel, sym, (unsigned int*)(rel->r_offset + initd->ld_start), initd->ld_start); rel++; } n++; rel = (Elf32_Rel*)dync.data[DT_JMPREL]; rsize = dync.data[DT_PLTRELSZ]; }while(n < 2 && dync.data[DT_PLTREL] == DT_REL); // relocate DT_RELA (if JMPREL is of type DT_RELA we will initialize it here) rela = (Elf32_Rela*)dync.data[DT_RELA]; rsize = dync.data[DT_RELASZ]; n = 0; do { for (i = 0; i < rsize; i += sizeof(Elf32_Rela)) { sym = (Elf32_Sym*)(dync.data[DT_SYMTAB] + sizeof(Elf32_Sym) * ELF32_R_SYM(rel->r_info)); // get the symbol from the table by adding it's offset RELOC_RELA(rela, sym, (unsigned int*)(rel->r_offset + initd->ld_start), initd->ld_start); rela++; } n++; rela = (Elf32_Rela*)dync.data[DT_JMPREL]; rsize = dync.data[DT_PLTRELSZ]; }while(n < 2 && dync.data[DT_PLTREL] == DT_RELA); __ldmain(initd, &dync); return initd->prg_start; }