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

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