Usermode/Libraries/ld-acess.so_src/elf.c

   1 /*
   2  * AcessOS 1 - Dynamic Loader
   3  * By thePowersGang
   4  */
   5 #include "common.h"
   6 #include <stdint.h>
   7 #include "elf32.h"
   8
   9 #define DEBUG   0
  10
  11 #if DEBUG
  12 # define        DEBUGS(v...)    SysDebug(v)
  13 #else
  14 # define        DEBUGS(...)
  15 #endif
  16
  17 // === CONSTANTS ===
  18 #if DEBUG
  19 //static const char     *csaDT_NAMES[] = {"DT_NULL", "DT_NEEDED", "DT_PLTRELSZ", "DT_PLTGOT", "DT_HASH", "DT_STRTAB", "DT_SYMTAB", "DT_RELA", "DT_RELASZ", "DT_RELAENT", "DT_STRSZ", "DT_SYMENT", "DT_INIT", "DT_FINI", "DT_SONAME", "DT_RPATH", "DT_SYMBOLIC", "DT_REL", "DT_RELSZ", "DT_RELENT", "DT_PLTREL", "DT_DEBUG", "DT_TEXTREL", "DT_JMPREL"};
  20 static const char       *csaR_NAMES[] = {"R_386_NONE", "R_386_32", "R_386_PC32", "R_386_GOT32", "R_386_PLT32", "R_386_COPY", "R_386_GLOB_DAT", "R_386_JMP_SLOT", "R_386_RELATIVE", "R_386_GOTOFF", "R_386_GOTPC", "R_386_LAST"};
  21 #endif
  22
  23 // === PROTOTYPES ===
  24 Uint32 ElfHashString(const char *name);
  25
  26 // === CODE ===
  27 /**
  28  \fn int ElfRelocate(void *Base, char **envp, char *Filename)
  29  \brief Relocates a loaded ELF Executable
  30 */
  31 void *ElfRelocate(void *Base, char **envp, char *Filename)
  32 {
  33         Elf32_Ehdr      *hdr = Base;
  34         Elf32_Phdr      *phtab;
  35          int    i, j;   // Counters
  36         char    *libPath;
  37         Uint    iRealBase = -1;
  38         Uint    iBaseDiff;
  39          int    iSegmentCount;
  40          int    iSymCount;
  41         Elf32_Rel       *rel = NULL;
  42         Elf32_Rela      *rela = NULL;
  43         Uint32  *pltgot = NULL;
  44         void    *plt = NULL;
  45          int    relSz=0, relEntSz=8;
  46          int    relaSz=0, relaEntSz=8;
  47          int    pltSz=0, pltType=0;
  48         Elf32_Dyn       *dynamicTab = NULL;     // Dynamic Table Pointer
  49         char    *dynstrtab = NULL;      // .dynamic String Table
  50         Elf32_Sym       *dynsymtab;
  51
  52         DEBUGS("ElfRelocate: (Base=0x%x)", Base);
  53
  54         // Check magic header
  55
  56
  57         // Parse Program Header to get Dynamic Table
  58         phtab = Base + hdr->phoff;
  59         iSegmentCount = hdr->phentcount;
  60         for(i=0;i<iSegmentCount;i++)
  61         {
  62                 // Determine linked base address
  63                 if(phtab[i].Type == PT_LOAD && iRealBase > phtab[i].VAddr)
  64                         iRealBase = phtab[i].VAddr;
  65
  66                 // Find Dynamic Section
  67                 if(phtab[i].Type == PT_DYNAMIC) {
  68                         if(dynamicTab) {
  69                                 DEBUGS(" WARNING - elf_relocate: Multiple PT_DYNAMIC segments");
  70                                 continue;
  71                         }
  72                         dynamicTab = (void *) (intptr_t) phtab[i].VAddr;
  73                         j = i;  // Save Dynamic Table ID
  74                 }
  75         }
  76
  77         // Page Align real base
  78         iRealBase &= ~0xFFF;
  79         DEBUGS(" elf_relocate: True Base = 0x%x, Compiled Base = 0x%x", Base, iRealBase);
  80
  81         // Adjust "Real" Base
  82         iBaseDiff = (intptr_t)Base - iRealBase;
  83
  84 //      hdr->entrypoint += iBaseDiff;   // Adjust Entrypoint
  85
  86         // Check if a PT_DYNAMIC segement was found
  87         if(!dynamicTab) {
  88                 SysDebug(" elf_relocate: No PT_DYNAMIC segment in image %p, returning", Base);
  89                 return (void *)hdr->entrypoint + iBaseDiff;
  90         }
  91
  92         // Adjust Dynamic Table
  93         dynamicTab = (void *)( (intptr_t)dynamicTab + iBaseDiff );
  94
  95         // === Get Symbol table and String Table ===
  96         for( j = 0; dynamicTab[j].d_tag != DT_NULL; j++)
  97         {
  98                 switch(dynamicTab[j].d_tag)
  99                 {
 100                 // --- Symbol Table ---
 101                 case DT_SYMTAB:
 102                         DEBUGS(" elf_relocate: DYNAMIC Symbol Table 0x%x (0x%x)",
 103                                 dynamicTab[j].d_val, dynamicTab[j].d_val + iBaseDiff);
 104                         if(iBaseDiff != 0)      dynamicTab[j].d_val += iBaseDiff;
 105                         dynsymtab = (void*)(dynamicTab[j].d_val);
 106 //                      hdr->misc.SymTable = dynamicTab[j].d_val;       // Saved in unused bytes of ident
 107                         break;
 108                 // --- String Table ---
 109                 case DT_STRTAB:
 110                         DEBUGS(" elf_relocate: DYNAMIC String Table 0x%x (0x%x)",
 111                                 dynamicTab[j].d_val, dynamicTab[j].d_val + iBaseDiff);
 112                         if(iBaseDiff != 0)      dynamicTab[j].d_val += iBaseDiff;
 113                         dynstrtab = (void*)(dynamicTab[j].d_val);
 114                         break;
 115                 // --- Hash Table --
 116                 case DT_HASH:
 117                         if(iBaseDiff != 0)      dynamicTab[j].d_val += iBaseDiff;
 118                         iSymCount = ((Uint*)(dynamicTab[j].d_val))[1];
 119 //                      hdr->misc.HashTable = dynamicTab[j].d_val;      // Saved in unused bytes of ident
 120                         break;
 121                 }
 122         }
 123
 124         if(dynsymtab == NULL) {
 125                 SysDebug("ld-acess.so - WARNING: No Dynamic Symbol table in %p, returning", hdr);
 126                 return (void *) hdr->entrypoint + iBaseDiff;
 127         }
 128
 129         #if 0
 130         // Alter Symbols to true base
 131         for(i=0;i<iSymCount;i++)
 132         {
 133                 dynsymtab[i].value += iBaseDiff;
 134                 dynsymtab[i].nameOfs += (intptr_t)dynstrtab;
 135                 //DEBUGS("elf_relocate: Sym '%s' = 0x%x (relocated)", dynsymtab[i].name, dynsymtab[i].value);
 136         }
 137         #endif
 138
 139         // === Add to loaded list (can be imported now) ===
 140         AddLoaded( Filename, Base );
 141
 142         // === Parse Relocation Data ===
 143         DEBUGS(" elf_relocate: dynamicTab = 0x%x", dynamicTab);
 144         for( j = 0; dynamicTab[j].d_tag != DT_NULL; j++)
 145         {
 146                 switch(dynamicTab[j].d_tag)
 147                 {
 148                 // --- Shared Library Name ---
 149                 case DT_SONAME:
 150                         DEBUGS(" elf_relocate: .so Name '%s'", dynstrtab+dynamicTab[j].d_val);
 151                         break;
 152                 // --- Needed Library ---
 153                 case DT_NEEDED:
 154                         libPath = dynstrtab + dynamicTab[j].d_val;
 155                         DEBUGS(" Required Library '%s'", libPath);
 156                         if(LoadLibrary(libPath, NULL, envp) == 0) {
 157                                 #if DEBUG
 158                                         DEBUGS(" elf_relocate: Unable to load '%s'", libPath);
 159                                 #else
 160                                 SysDebug("Unable to load required library '%s'", libPath);
 161                                 #endif
 162                                 return 0;
 163                         }
 164                         break;
 165                 // --- PLT/GOT ---
 166                 case DT_PLTGOT: pltgot = (void*)(iBaseDiff + dynamicTab[j].d_val);      break;
 167                 case DT_JMPREL: plt = (void*)(iBaseDiff + dynamicTab[j].d_val); break;
 168                 case DT_PLTREL: pltType = dynamicTab[j].d_val;  break;
 169                 case DT_PLTRELSZ:       pltSz = dynamicTab[j].d_val;    break;
 170
 171                 // --- Relocation ---
 172                 case DT_REL:    rel = (void*)(iBaseDiff + dynamicTab[j].d_val); break;
 173                 case DT_RELSZ:  relSz = dynamicTab[j].d_val;    break;
 174                 case DT_RELENT: relEntSz = dynamicTab[j].d_val; break;
 175                 case DT_RELA:   rela = (void*)(iBaseDiff + dynamicTab[j].d_val);        break;
 176                 case DT_RELASZ: relaSz = dynamicTab[j].d_val;   break;
 177                 case DT_RELAENT:        relaEntSz = dynamicTab[j].d_val;        break;
 178
 179                 // --- Symbol Table ---
 180                 case DT_SYMTAB:
 181                 // --- Hash Table ---
 182                 case DT_HASH:
 183                 // --- String Table ---
 184                 case DT_STRTAB:
 185                         break;
 186
 187                 // --- Unknown ---
 188                 default:
 189                         if(dynamicTab[j].d_tag > DT_JMPREL)     continue;
 190                         //DEBUGS(" elf_relocate: %i-%i = %s,0x%x",
 191                         //      i,j, csaDT_NAMES[dynamicTab[j].d_tag],dynamicTab[j].d_val);
 192                         break;
 193                 }
 194         }
 195
 196         DEBUGS(" elf_relocate: Beginning Relocation");
 197
 198         void elf_doRelocate(Uint r_info, Uint32 *ptr, Uint32 addend, Elf32_Sym *symtab)
 199         {
 200                  int    type = ELF32_R_TYPE(r_info);
 201                  int    sym = ELF32_R_SYM(r_info);
 202                 Uint32  val;
 203                 const char      *symname = dynstrtab + symtab[sym].nameOfs;
 204                 switch( type )
 205                 {
 206                 // Standard 32 Bit Relocation (S+A)
 207                 case R_386_32:
 208                         val = (intptr_t) GetSymbol( symname );
 209                         DEBUGS(" elf_doRelocate: R_386_32 *0x%x += 0x%x('%s')",
 210                                         ptr, val, symname);
 211                         *ptr = val + addend;
 212                         break;
 213
 214                 // 32 Bit Relocation wrt. Offset (S+A-P)
 215                 case R_386_PC32:
 216                         DEBUGS(" elf_doRelocate: #%i: '%s'", sym, symname);
 217                         val = (intptr_t) GetSymbol( symname );
 218                         DEBUGS(" elf_doRelocate: R_386_PC32 *0x%x = 0x%x + 0x%x - 0x%x",
 219                                 ptr, *ptr, val, (Uint)ptr );
 220                         *ptr = val + addend - (intptr_t)ptr;
 221                         //*ptr = val + addend - ((Uint)ptr - iBaseDiff);
 222                         break;
 223
 224                 // Absolute Value of a symbol (S)
 225                 case R_386_GLOB_DAT:
 226                 case R_386_JMP_SLOT:
 227                         DEBUGS(" elf_doRelocate: #%i: '%s'", sym, symname);
 228                         val = (intptr_t) GetSymbol( symname );
 229                         DEBUGS(" elf_doRelocate: %s *0x%x = 0x%x", csaR_NAMES[type], ptr, val);
 230                         *ptr = val;
 231                         break;
 232
 233                 // Base Address (B+A)
 234                 case R_386_RELATIVE:
 235                         DEBUGS(" elf_doRelocate: R_386_RELATIVE *0x%x = 0x%x + 0x%x", ptr, iBaseDiff, addend);
 236                         *ptr = iBaseDiff + addend;
 237                         break;
 238
 239                 default:
 240                         DEBUGS(" elf_doRelocate: Rel 0x%x: 0x%x,%s", ptr, sym, csaR_NAMES[type]);
 241                         break;
 242                 }
 243         }
 244
 245         // Parse Relocation Entries
 246         if(rel && relSz)
 247         {
 248                 Uint32  *ptr;
 249                 DEBUGS(" elf_relocate: rel=0x%x, relSz=0x%x, relEntSz=0x%x", rel, relSz, relEntSz);
 250                 j = relSz / relEntSz;
 251                 for( i = 0; i < j; i++ )
 252                 {
 253                         //DEBUGS("  Rel %i: 0x%x+0x%x", i, iBaseDiff, rel[i].r_offset);
 254                         ptr = (void*)(iBaseDiff + rel[i].r_offset);
 255                         elf_doRelocate(rel[i].r_info, ptr, *ptr, dynsymtab);
 256                 }
 257         }
 258         // Parse Relocation Entries
 259         if(rela && relaSz)
 260         {
 261                 Uint32  *ptr;
 262                 DEBUGS(" elf_relocate: rela=0x%x, relaSz=0x%x, relaEntSz=0x%x", rela, relaSz, relaEntSz);
 263                 j = relaSz / relaEntSz;
 264                 for( i = 0; i < j; i++ )
 265                 {
 266                         ptr = (void*)(iBaseDiff + rela[i].r_offset);
 267                         elf_doRelocate(rel[i].r_info, ptr, rela[i].r_addend, dynsymtab);
 268                 }
 269         }
 270
 271         // === Process PLT (Procedure Linkage Table) ===
 272         if(plt && pltSz)
 273         {
 274                 Uint32  *ptr;
 275                 DEBUGS(" elf_relocate: Relocate PLT, plt=0x%x", plt);
 276                 if(pltType == DT_REL)
 277                 {
 278                         Elf32_Rel       *pltRel = plt;
 279                         j = pltSz / sizeof(Elf32_Rel);
 280                         DEBUGS(" elf_relocate: PLT Reloc Type = Rel, %i entries", j);
 281                         for(i=0;i<j;i++)
 282                         {
 283                                 ptr = (void*)(iBaseDiff + pltRel[i].r_offset);
 284                                 elf_doRelocate(pltRel[i].r_info, ptr, *ptr, dynsymtab);
 285                         }
 286                 }
 287                 else
 288                 {
 289                         Elf32_Rela      *pltRela = plt;
 290                         j = pltSz / sizeof(Elf32_Rela);
 291                         DEBUGS(" elf_relocate: PLT Reloc Type = Rela, %i entries", j);
 292                         for(i=0;i<j;i++)
 293                         {
 294                                 ptr = (void*)(iRealBase + pltRela[i].r_offset);
 295                                 elf_doRelocate(pltRela[i].r_info, ptr, pltRela[i].r_addend, dynsymtab);
 296                         }
 297                 }
 298         }
 299
 300         DEBUGS("ElfRelocate: RETURN 0x%x", hdr->entrypoint + iBaseDiff);
 301         return (void*)hdr->entrypoint + iBaseDiff;
 302 }
 303
 304
 305 /**
 306  * \fn int ElfGetSymbol(Uint Base, const char *name, void **ret)
 307  */
 308 int ElfGetSymbol(void *Base, const char *Name, void **ret)
 309 {
 310         Elf32_Ehdr      *hdr = Base;
 311         Elf32_Sym       *symtab;
 312          int    nbuckets = 0;
 313          int    iSymCount = 0;
 314          int    i;
 315         Uint32  *pBuckets;
 316         Uint32  *pChains;
 317         Uint    iNameHash;
 318         const char      *dynstrtab;
 319         uintptr_t       iBaseDiff = -1;
 320
 321         //DEBUGS("ElfGetSymbol: (Base=0x%x, Name='%s')", Base, Name);
 322         #if 0
 323         pBuckets = (void *) (intptr_t) hdr->misc.HashTable;
 324         symtab = (void *) (intptr_t) hdr->misc.SymTable;
 325         dynstrtab = (void *) (intptr_t) hdr->misc.StrTab;
 326         #else
 327         dynstrtab = NULL;
 328         pBuckets = NULL;
 329         symtab = NULL;
 330         #endif
 331
 332         // Catch the current executable
 333         if( !pBuckets )
 334         {
 335                 Elf32_Phdr      *phtab;
 336                 Elf32_Dyn       *dynTab = NULL;
 337                  int    j;
 338
 339                 // Locate the tables
 340                 phtab = (void*)( Base + hdr->phoff );
 341                 for( i = 0; i < hdr->phentcount; i ++ )
 342                 {
 343                         if(phtab[i].Type == PT_LOAD && iBaseDiff > phtab[i].VAddr)
 344                                 iBaseDiff = phtab[i].VAddr;
 345                         if( phtab[i].Type == PT_DYNAMIC ) {
 346                                 dynTab = (void*)phtab[i].VAddr;
 347                         }
 348                 }
 349                 if( !dynTab ) {
 350                         SysDebug("ERROR - Unable to find DYNAMIC segment in %p");
 351                         return 0;
 352                 }
 353                 iBaseDiff = (intptr_t)Base - iBaseDiff; // Make iBaseDiff actually the diff
 354                 dynTab = (void*)( (intptr_t)dynTab + iBaseDiff );
 355
 356                 for( j = 0; dynTab[j].d_tag != DT_NULL; j++)
 357                 {
 358                         switch(dynTab[j].d_tag)
 359                         {
 360                         // --- Symbol Table ---
 361                         case DT_SYMTAB:
 362                                 symtab = (void*)(intptr_t) dynTab[j].d_val;     // Rebased in Relocate
 363                                 break;
 364                         case DT_STRTAB:
 365                                 dynstrtab = (void*)(intptr_t) dynTab[j].d_val;
 366                                 break;
 367                         // --- Hash Table --
 368                         case DT_HASH:
 369                                 pBuckets = (void*)(intptr_t) dynTab[j].d_val;
 370                                 break;
 371                         }
 372                 }
 373
 374                 #if 0
 375                 hdr->misc.HashTable = pBucktets;
 376                 hdr->misc.SymTable = symtab;
 377                 hdr->misc.StrTab = dynstrtab;
 378                 #endif
 379         }
 380
 381         nbuckets = pBuckets[0];
 382         iSymCount = pBuckets[1];
 383         pBuckets = &pBuckets[2];
 384         pChains = &pBuckets[ nbuckets ];
 385
 386         // Get hash
 387         iNameHash = ElfHashString(Name);
 388         iNameHash %= nbuckets;
 389         //DEBUGS(" ElfGetSymbol: iNameHash = 0x%x", iNameHash);
 390
 391         // Walk Chain
 392         i = pBuckets[ iNameHash ];
 393         //DEBUGS(" ElfGetSymbol: strcmp(Name, \"%s\")", symtab[i].name);
 394         if(symtab[i].shndx != SHN_UNDEF && strcmp(dynstrtab + symtab[i].nameOfs, Name) == 0) {
 395                 *ret = (void*) (intptr_t) symtab[ i ].value + iBaseDiff;
 396                 return 1;
 397         }
 398
 399         //DEBUGS(" ElfGetSymbol: Hash of first = 0x%x", ElfHashString( symtab[i].name ) % nbuckets);
 400         while(pChains[i] != STN_UNDEF)
 401         {
 402                 //DEBUGS(" pChains[%i] = %i", i, pChains[i]);
 403                 i = pChains[i];
 404                 //DEBUGS(" ElfGetSymbol: strcmp(Name, \"%s\")", symtab[ i ].name);
 405                 if(symtab[i].shndx != SHN_UNDEF && strcmp(dynstrtab + symtab[ i ].nameOfs, Name) == 0) {
 406                         //DEBUGS("ElfGetSymbol: RETURN 1, '%s' = 0x%x", symtab[ i ].name, symtab[ i ].value);
 407                         *ret = (void*)(intptr_t)symtab[ i ].value + iBaseDiff;
 408                         return 1;
 409                 }
 410         }
 411
 412         //DEBUGS("ElfGetSymbol: RETURN 0, Symbol '%s' not found", Name);
 413         return 0;
 414 }
 415
 416 Uint32 ElfHashString(const char *name)
 417 {
 418         Uint32  h = 0, g;
 419         while(*name)
 420         {
 421                 h = (h << 4) + *(Uint8*)name++;
 422                 if( (g = h & 0xf0000000) )
 423                         h ^= g >> 24;
 424                 h &= ~g;
 425         }
 426         return h;
 427 }
 428
 429 #if 0
 430 unsigned long elf_hash(const unsigned char *name)
 431 {
 432         unsigned long   h = 0, g;
 433         while (*name)
 434         {
 435                 h = (h << 4) + *name++;
 436                 if (g = h & 0xf0000000)
 437                         h ^= g >> 24;
 438                 h &= ~g;
 439         }
 440         return h;
 441 }
 442 #endif