bootstrap/elfloader.c

   1 /*
   2  Copyright (C) 2006-2011 The AROS Development Team. All rights reserved.
   3  $Id$
   4
   5  Desc: ELF loader extracted from our internal_load_seg_elf in dos.library.
   6  Lang: English
   7  */
   8
   9 #include <inttypes.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 /* Define this wrapper here, before loading AROS headers,
  15  * so that the defines in <aros/system.h> do not
  16  * confuse GCC's built-in substitutions for strcmp().
  17  */
  18 static inline int Strcmp(const char *a, const char *b) { return strcmp(a, b); }
  19
  20 #undef __pure2
  21 #undef __deprecated
  22
  23 #include <dos/elf.h>
  24 #include <libraries/debug.h>
  25
  26 #include <elfloader.h>
  27 #include <runtime.h>
  28
  29 #define D(x)
  30 #define DREL(x)
  31 #define DSYM(x)
  32
  33 /* Use own definitions because we may be compiled as 32-bit code but build structures for 64-bit code */
  34 struct ELF_ModuleInfo_t
  35 {
  36     elf_uintptr_t  Next;
  37     elf_uintptr_t  Name;
  38     unsigned short Type;
  39     unsigned short Pad0;        /* On i386 we have different alignment, so do explicit padding */
  40 #ifdef ELF_64BIT
  41     unsigned int   Pad1;
  42 #endif
  43     elf_uintptr_t  eh;
  44     elf_uintptr_t  sh;
  45 };
  46
  47 /* Our own definition of struct KernelBSS, to avoid excessive castings */
  48 struct KernelBSS_t
  49 {
  50     elf_uintptr_t addr;
  51     elf_uintptr_t len;
  52 };
  53
  54 static elf_uintptr_t SysBase_ptr = 0;
  55
  56 /*
  57  * Test for correct ELF header here
  58  */
  59 static char *check_header(struct elfheader *eh)
  60 {
  61     if (eh->ident[0] != 0x7f || eh->ident[1] != 'E'  ||
  62         eh->ident[2] != 'L'  || eh->ident[3] != 'F')
  63         return "Not a ELF file";
  64
  65     if (eh->type != ET_REL || eh->machine != AROS_ELF_MACHINE)
  66         return "Wrong object type or wrong architecture";
  67
  68     /* No error */
  69     return NULL;
  70 }
  71
  72 /*
  73  * Get the memory for chunk and load it
  74  */
  75 static void *load_hunk(void *file, struct sheader *sh, void *addr, struct KernelBSS_t **bss_tracker)
  76 {
  77     uintptr_t align;
  78
  79     /* empty chunk? Who cares :) */
  80     if (!sh->size)
  81         return addr;
  82
  83     D(kprintf("[ELF Loader] Chunk (%ld bytes, align=%ld (%p) @ ", sh->size, sh->addralign, (void *)sh->addralign));
  84     align = sh->addralign - 1;
  85     addr = (char *)(((uintptr_t)addr + align) & ~align);
  86
  87     D(kprintf("%p\n", addr));
  88     sh->addr = (elf_ptr_t)(uintptr_t)addr;
  89
  90     /* copy block of memory from ELF file if it exists */
  91     if (sh->type != SHT_NOBITS)
  92     {
  93         if (read_block(file, sh->offset, (void *)(uintptr_t)sh->addr, sh->size))
  94             return NULL;
  95     }
  96     else
  97     {
  98         memset(addr, 0, sh->size);
  99
 100         (*bss_tracker)->addr = (uintptr_t)addr;
 101         (*bss_tracker)->len = sh->size;
 102         (*bss_tracker)++;
 103     }
 104
 105     return addr + sh->size;
 106 }
 107
 108 static void *copy_data(void *src, void *addr, uintptr_t len)
 109 {
 110     memcpy(addr, src, len);
 111     return addr + len;
 112 }
 113
 114 /* Perform relocations of given section */
 115 static int relocate(struct elfheader *eh, struct sheader *sh, long shrel_idx, elf_uintptr_t DefSysBase)
 116 {
 117     struct sheader *shrel    = &sh[shrel_idx];
 118     struct sheader *shsymtab = &sh[shrel->link];
 119     struct sheader *toreloc  = &sh[shrel->info];
 120
 121     struct symbol *symtab   = (struct symbol *)(uintptr_t)shsymtab->addr;
 122     struct relo   *rel      = (struct relo *)(uintptr_t)shrel->addr;
 123     /* Early cast to uintptr_t omits __udivdi3 call in x86-64 native bootstrap */
 124     unsigned int numrel = (uintptr_t)shrel->size / (uintptr_t)shrel->entsize;
 125     unsigned int i;
 126
 127     struct symbol *SysBase_sym = NULL;
 128
 129     /*
 130      * Ignore relocs if the target section has no allocation. that can happen
 131      * eg. with a .debug PROGBITS and a .rel.debug section
 132      */
 133     if (!(toreloc->flags & SHF_ALLOC))
 134         return 1;
 135
 136     DREL(kprintf("[ELF Loader] performing %d relocations\n", numrel));
 137
 138     for (i=0; i<numrel; i++, rel++)
 139     {
 140         struct symbol *sym = &symtab[ELF_R_SYM(rel->info)];
 141         uintptr_t *p = (void *)(uintptr_t)toreloc->addr + rel->offset;
 142         const char *name = (const char *)(uintptr_t)sh[shsymtab->link].addr + sym->name;
 143         elf_uintptr_t s;
 144
 145 #ifdef __arm__
 146         /*
 147          * R_ARM_V4BX are actually special marks for the linker.
 148          * They even never have a target (shindex == SHN_UNDEF),
 149          * so we simply ignore them before doing any checks.
 150          */
 151         if (ELF_R_TYPE(rel->info) == R_ARM_V4BX)
 152             continue;
 153 #endif
 154
 155         switch (sym->shindex)
 156         {
 157         case SHN_UNDEF:
 158             if (Strcmp(name, "SysBase") == 0) {
 159                 if (!SysBase_ptr)
 160                 {
 161                     SysBase_ptr = DefSysBase;
 162                     D(kprintf("[ELF Loader] SysBase pointer set to default %p\n", (void *)SysBase_ptr));
 163                 }
 164
 165                 s = SysBase_ptr;
 166             } else {
 167                 kprintf("[ELF Loader] Undefined symbol '%s'\n", name);
 168                 return 0;
 169             }
 170             break;
 171
 172         case SHN_COMMON:
 173             kprintf("[ELF Loader] COMMON symbol '%s'\n", name);
 174             return 0;
 175
 176         case SHN_ABS:
 177             if (SysBase_sym == NULL)
 178             {
 179                 if (Strcmp(name, "SysBase") == 0)
 180                 {
 181                     DREL(kprintf("[ELF Loader] got SysBase\n"));
 182                     SysBase_sym = sym;
 183                 }
 184             }
 185
 186             if (SysBase_sym == sym)
 187             {
 188                 if (!SysBase_ptr)
 189                 {
 190                     SysBase_ptr = DefSysBase;
 191                     D(kprintf("[ELF Loader] SysBase pointer set to default %p\n", (void *)SysBase_ptr));
 192                 }
 193
 194                 s = SysBase_ptr;
 195             }
 196             else
 197                 s = sym->value;
 198             break;
 199
 200         default:
 201             s = (uintptr_t)sh[sym->shindex].addr + sym->value;
 202
 203             if (!SysBase_ptr)
 204             {
 205                 /*
 206                  * The first global data symbol named SysBase becomes global SysBase.
 207                  * The idea behind: the first module (kernel.resource) contains global
 208                  * SysBase variable and all other modules are linked to it.
 209                  */
 210                 if (sym->info == ELF_S_INFO(STB_GLOBAL, STT_OBJECT))
 211                 {
 212                     if (Strcmp(name, "SysBase") == 0)
 213                     {
 214                         SysBase_ptr = s;
 215                         D(kprintf("[ELF Loader] SysBase pointer set to %p\n", (void *)SysBase_ptr));
 216                     }
 217                 }
 218             }
 219         }
 220
 221         DREL(kprintf("[ELF Loader] Relocating symbol %s type ", sym->name ? name : "<unknown>"));
 222         switch (ELF_R_TYPE(rel->info))
 223         {
 224 #ifdef ELF_64BIT
 225         case R_X86_64_64: /* 64bit direct/absolute */
 226             *(uint64_t *)p = s + rel->addend;
 227             break;
 228
 229         case R_X86_64_PC32: /* PC relative 32 bit signed */
 230             *(uint32_t *)p = s + rel->addend - (uintptr_t) p;
 231             break;
 232
 233         case R_X86_64_32:
 234             *(uint32_t *)p = (uint64_t)s + (uint64_t)rel->addend;
 235             break;
 236
 237         case R_X86_64_32S:
 238             *(int32_t *)p = (int64_t)s + (int64_t)rel->addend;
 239             break;
 240
 241         case R_X86_64_NONE: /* No reloc */
 242             break;
 243 #else
 244 #ifdef __i386__
 245         case R_386_32: /* 32bit absolute */
 246             DREL(kprintf("R_386_32"));
 247             *p += s;
 248             break;
 249
 250         case R_386_PC32: /* 32bit PC relative */
 251             DREL(kprintf("R_386_PC32"));
 252             *p += (s - (uintptr_t)p);
 253             break;
 254
 255         case R_386_NONE:
 256             DREL(kprintf("R_386_NONE"));
 257             break;
 258 #endif
 259 #endif
 260 #ifdef __mc68000__
 261         case R_68K_32:
 262             *p = s + rel->addend;
 263             break;
 264
 265         case R_68K_PC32:
 266             *p = s + rel->addend - (uint32_t)p;
 267             break;
 268
 269         case R_68k_NONE:
 270             break;
 271 #endif
 272 #if defined(__ppc__) || defined(__powerpc__)
 273         case R_PPC_ADDR32:
 274             *p = s + rel->addend;
 275             break;
 276
 277         case R_PPC_ADDR16_LO:
 278         {
 279             unsigned short *c = (unsigned short *) p;
 280             *c = (s + rel->addend) & 0xffff;
 281         }
 282         break;
 283
 284         case R_PPC_ADDR16_HA:
 285         {
 286             unsigned short *c = (unsigned short *) p;
 287             uint32_t temp = s + rel->addend;
 288             *c = temp >> 16;
 289             if ((temp & 0x8000) != 0)
 290                 (*c)++;
 291         }
 292         break;
 293
 294         case R_PPC_REL16_LO:
 295         {
 296             unsigned short *c = (unsigned short *) p;
 297             *c = (s + rel->addend - (uint32_t)p) & 0xffff;
 298         }
 299         break;
 300
 301         case R_PPC_REL16_HA:
 302         {
 303             unsigned short *c = (unsigned short *) p;
 304             uint32_t temp = s + rel->addend - (uint32_t)p;
 305             *c = temp >> 16;
 306             if ((temp & 0x8000) != 0)
 307                         (*c)++;
 308         }
 309         break;
 310
 311         case R_PPC_REL24:
 312             *p &= ~0x3fffffc;
 313             *p |= (s + rel->addend - (uint32_t)p) & 0x3fffffc;
 314             break;
 315
 316         case R_PPC_REL32:
 317             *p = s + rel->addend - (uint32_t)p;
 318             break;
 319
 320         case R_PPC_NONE:
 321             break;
 322 #endif
 323 #ifdef __arm__
 324         case R_ARM_CALL:
 325         case R_ARM_JUMP24:
 326         case R_ARM_PC24:
 327         case R_ARM_PREL31:
 328             {
 329                 /* On ARM the 24 bit offset is shifted by 2 to the right */
 330                 signed long offset = (*p & 0x00ffffff) << 2;
 331                 /* If highest bit set, make offset negative */
 332                 if (offset & 0x02000000)
 333                     offset -= 0x04000000;
 334
 335                 offset += s - (uint32_t)p;
 336
 337                 offset >>= 2;
 338                 *p &= 0xff000000;
 339                 *p |= offset & 0x00ffffff;
 340             }
 341             break;
 342
 343         case R_ARM_MOVW_ABS_NC:
 344         case R_ARM_MOVT_ABS:
 345             {
 346                 signed long offset = *p;
 347                 offset = ((offset & 0xf0000) >> 4) | (offset & 0xfff);
 348                 offset = (offset ^ 0x8000) - 0x8000;
 349
 350                 offset += s;
 351
 352                 if (ELF_R_TYPE(rel->info) == R_ARM_MOVT_ABS)
 353                     offset >>= 16;
 354
 355                 *p &= 0xfff0f000;
 356                 *p |= ((offset & 0xf000) << 4) | (offset & 0x0fff);
 357             }
 358             break;
 359
 360         case R_ARM_ABS32:
 361             *p += s;
 362             break;
 363
 364         case R_ARM_NONE:
 365             break;
 366 #endif
 367         default:
 368             kprintf("[ELF Loader] Unrecognized relocation type %d %ld\n", i, (long)ELF_R_TYPE(rel->info));
 369             return 0;
 370         }
 371         DREL(kprintf(" -> %p\n", *p));
 372     }
 373     return 1;
 374 }
 375
 376 int GetKernelSize(struct ELFNode *FirstELF, unsigned long *ro_size, unsigned long *rw_size, unsigned long *bss_size)
 377 {
 378     struct ELFNode *n;
 379     unsigned long ksize = 0;
 380     unsigned long rwsize = 0;
 381     unsigned long bsize = sizeof(struct KernelBSS_t);
 382     unsigned short i;
 383
 384     kprintf("[ELF Loader] Calculating kickstart size...\n");
 385
 386     for (n = FirstELF; n; n = n->Next)
 387     {
 388         void *file;
 389         char *errstr = NULL;
 390         unsigned int err;
 391
 392         D(kprintf("[ELF Loader] Checking file %s\n", n->Name));
 393
 394         file = open_file(n, &err);
 395         if (err)
 396         {
 397             DisplayError("Failed to open file %s!\n", n->Name);
 398             return 0;
 399         }
 400
 401         /* Check the header of ELF file */
 402         n->eh = load_block(file, 0, sizeof(struct elfheader), &err);
 403         if (err)
 404         {
 405             errstr = "Failed to read file header";
 406         }
 407         else
 408         {
 409             errstr = check_header(n->eh);
 410             if (!errstr)
 411             {
 412                 n->sh = load_block(file, n->eh->shoff, n->eh->shnum * n->eh->shentsize, &err);
 413                 if (err)
 414                 {
 415                     errstr = "Failed to read section headers";
 416                 }
 417             }
 418         }
 419
 420         close_file(file);
 421         if (errstr)
 422         {
 423             DisplayError("%s: %s\n", n->Name, errstr);
 424             return 0;
 425         }
 426
 427         /*
 428          * Debug data for the module includes:
 429          * - Module descriptor (struct ELF_ModuleInfo_t)
 430          * - ELF file header
 431          * - ELF section header
 432          * - File name
 433          * - One empty pointer for alignment
 434          */
 435         ksize += (sizeof(struct ELF_ModuleInfo_t) + sizeof(struct elfheader) + n->eh->shnum * n->eh->shentsize  +
 436                   strlen(n->Name) + sizeof(void *));
 437
 438         /* Go through all sections and calculate kernel size */
 439         for(i = 0; i < n->eh->shnum; i++)
 440         {
 441             /* Ignore sections with zero lengths */
 442             if (!n->sh[i].size)
 443                 continue;
 444
 445             /*
 446              * We will load:
 447              * - Actual code and data (allocated sections)
 448              * - String tables (for debug data)
 449              * - Symbol tables (for debug data)
 450              */
 451             if ((n->sh[i].flags & SHF_ALLOC) || (n->sh[i].type == SHT_STRTAB) || (n->sh[i].type == SHT_SYMTAB))
 452             {
 453                 /* Add maximum space for alignment */
 454                 unsigned long s = n->sh[i].size + n->sh[i].addralign - 1;
 455
 456                 if (n->sh[i].flags & SHF_WRITE)
 457                     rwsize += s;
 458                 else
 459                     ksize += s;
 460
 461                 if (n->sh[i].type == SHT_NOBITS)
 462                     bsize += sizeof(struct KernelBSS_t);
 463             }
 464         }
 465     }
 466
 467     *ro_size = ksize;
 468     *rw_size = rwsize;
 469
 470     if (bss_size)
 471         *bss_size = bsize;
 472
 473     kprintf("[ELF Loader] Code %lu bytes, data %lu bytes, BSS array %lu bytes\n", ksize, rwsize, bsize);
 474
 475     return 1;
 476 }
 477
 478 /*
 479  * This function loads the listed modules.
 480  * It expects that ELF and section header pointers in the list are already set up by GetKernelSize().
 481  *
 482  * (elf_ptr_t)(uintptr_t) double-casting is needed because in some cases elf_ptr_t is an UQUAD,
 483  * while in most cases it's a pointer (see dos/elf.h).
 484  */
 485 int LoadKernel(struct ELFNode *FirstELF, void *ptr_ro, void *ptr_rw, char *tracker_p, uintptr_t DefSysBase,
 486                void **kick_end, kernel_entry_fun_t *kernel_entry, struct ELF_ModuleInfo **kernel_debug)
 487 {
 488     struct ELFNode *n;
 489     unsigned int i;
 490     unsigned char need_entry = 1;
 491     struct ELF_ModuleInfo_t *mod;
 492     struct ELF_ModuleInfo_t *prev_mod = NULL;
 493     struct KernelBSS_t *tracker = (struct KernelBSS_t *)tracker_p;
 494
 495     kprintf("[ELF Loader] Loading kickstart...\n");
 496
 497     for (n = FirstELF; n; n = n->Next)
 498     {
 499         void *file;
 500         unsigned int err;
 501
 502         kprintf("[ELF Loader] Code %p, Data %p, Module %s...\n", ptr_ro, ptr_rw, n->Name);
 503
 504         file = open_file(n, &err);
 505         if (err)
 506         {
 507             DisplayError("Failed to open file %s!\n", n->Name);
 508             return 0;
 509         }
 510
 511         /* Iterate over the section header in order to load some hunks */
 512         for (i=0; i < n->eh->shnum; i++)
 513         {
 514             struct sheader *sh = n->sh;
 515
 516             D(kprintf("[ELF Loader] Section %u... ", i));
 517
 518             if ((sh[i].flags & SHF_ALLOC) || (sh[i].type == SHT_STRTAB) || (sh[i].type == SHT_SYMTAB))
 519             {
 520                 /* Does the section require memory allcation? */
 521                 D(kprintf("Allocated section\n"));
 522
 523                 if (sh[i].flags & SHF_WRITE)
 524                 {
 525                     ptr_rw = load_hunk(file, &sh[i], (void *)ptr_rw, &tracker);
 526                     if (!ptr_rw)
 527                     {
 528                         DisplayError("%s: Error loading hunk %u!\n", n->Name, i);
 529                         return 0;
 530                     }
 531                 }
 532                 else
 533                 {
 534                     ptr_ro = load_hunk(file, &sh[i], (void *)ptr_ro, &tracker);
 535                     if (!ptr_ro)
 536                     {
 537                         DisplayError("%s: Error loading hunk %u!\n", n->Name, i);
 538                         return 0;
 539                     }
 540                 }
 541
 542                 /* Remember address of the first code section, this is our entry point */
 543                 if ((sh[i].flags & SHF_EXECINSTR) && need_entry)
 544                 {
 545                     *kernel_entry = (void *)(uintptr_t)sh[i].addr;
 546                     need_entry = 0;
 547                 }
 548             }
 549                 D(else kprintf("Ignored\n");)
 550
 551             D(kprintf("[ELF Loader] Section address: %p, size: %lu\n", sh[i].addr, sh[i].size));
 552         }
 553
 554         /* For every loaded section perform relocations */
 555         D(kprintf("[ELF Loader] Relocating...\n"));
 556         for (i=0; i < n->eh->shnum; i++)
 557         {
 558             struct sheader *sh = n->sh;
 559
 560             if ((sh[i].type == AROS_ELF_REL) && sh[sh[i].info].addr)
 561             {
 562                 sh[i].addr = (elf_ptr_t)(uintptr_t)load_block(file, sh[i].offset, sh[i].size, &err);
 563                 if (err)
 564                 {
 565                     DisplayError("%s: Failed to load relocation section %u\n", n->Name, i);
 566                     return 0;
 567                 }
 568
 569                 if (!relocate(n->eh, sh, i, (uintptr_t)DefSysBase))
 570                 {
 571                     DisplayError("%s: Relocation error in section %u!\n", n->Name, i);
 572                     return 0;
 573                 }
 574
 575                 free_block((void *)(uintptr_t)sh[i].addr);
 576                 sh[i].addr = (elf_ptr_t)0;
 577             }
 578         }
 579
 580         close_file(file);
 581
 582         D(kprintf("[ELF Loader] Adding module debug information...\n"));
 583
 584         /* Align our pointer */
 585         ptr_ro = (void *)(((uintptr_t)ptr_ro + sizeof(void *)) & ~(sizeof(void *) - 1));
 586
 587         /* Allocate module descriptor */
 588         mod = ptr_ro;
 589         ptr_ro += sizeof(struct ELF_ModuleInfo_t);
 590         mod->Next = 0;
 591         mod->Type = DEBUG_ELF;
 592
 593         /* Copy ELF header */
 594         mod->eh  = (uintptr_t)ptr_ro;
 595         ptr_ro = copy_data(n->eh, ptr_ro, sizeof(struct elfheader));
 596
 597         /* Copy section header */
 598         mod->sh = (uintptr_t)ptr_ro;
 599         ptr_ro = copy_data(n->sh, ptr_ro, n->eh->shnum * n->eh->shentsize);
 600
 601         /* Copy module name */
 602         mod->Name = (uintptr_t)ptr_ro;
 603         ptr_ro = copy_data(n->Name, ptr_ro, strlen(n->Name) + 1);
 604
 605         /* Link the module descriptor with previous one */
 606         if (prev_mod)
 607             prev_mod->Next = (uintptr_t)mod;
 608         else
 609             *kernel_debug = (struct ELF_ModuleInfo *)mod;
 610         prev_mod = mod;
 611
 612         free_block(n->sh);
 613         free_block(n->eh);
 614     }
 615
 616     /* Terminate the array of BSS sections */
 617     tracker->addr = 0;
 618     tracker->len  = 0;
 619
 620     /* Return end of kickstart read-only area if requested */
 621     if (kick_end)
 622         *kick_end = ptr_ro;
 623
 624     return 1;
 625 }