arch/i386-darwin/bootstrap/elfloader32.c

   1 /*
   2  Copyright (C) 2006 The AROS Development Team. All rights reserved.
   3  $Id$
   4
   5  Desc: ELF32 loader extracted from our internal_load_seg_elf in dos.library.
   6  Lang: English
   7  */
   8
   9 #define DEBUG
  10 #define NATIVE
  11
  12 #include "../include/aros/kernel.h"
  13 #include "elfloader32.h"
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <strings.h>
  17 //#include "screen.h"
  18 //#include "bootstrap.h"
  19 //#include "support.h"
  20
  21 #ifdef DEBUG
  22 #define D
  23 #else
  24 #define D(X)
  25 #endif
  26 #define kprintf printf
  27
  28 /*
  29  * This two pointers are used by the ELF loader to claim for memory ranges for both
  30  * the RW sections (.data, .bss and such) and RO sections (.text, .rodata....) of executable.
  31  * Keeping both areas of memory separate reduces the memory waste when more modules are
  32  * loaded. Moreover, the whole RO range may be marked for MMU as read-only at once.
  33  */
  34 char *ptr_ro = 0;
  35 char *ptr_rw = 0;
  36 void ** SysBaseAddr;
  37
  38 struct _bss_tracker {
  39   unsigned long long addr;
  40   unsigned long long len;
  41 } *bss_tracker;
  42
  43 void *kernel_lowest()
  44 {
  45   return ptr_rw;
  46 }
  47
  48 void *kernel_highest()
  49 {
  50   return ptr_ro;
  51 }
  52
  53 void set_base_address(void *ptr, void *tracker, void ** sysbaseaddr)
  54 {
  55   printf("[ELF Loader] set_base_address %p %p %p\n",ptr,tracker,sysbaseaddr);
  56   ptr_ro = ptr_rw = ptr;
  57   bss_tracker = (struct _bss_tracker *)tracker;
  58   SysBaseAddr = sysbaseaddr;
  59 }
  60
  61 /*
  62  * read_block interface. we want to read from files here
  63  */
  64 static int read_block(void *file, long offset, void *dest, long length)
  65 {
  66   fseek(file, offset, SEEK_SET);
  67   fread(dest,(size_t)length, 1, file);
  68   return 1;
  69 }
  70
  71 /*
  72  * load_block also allocates teh memory
  73  */
  74 static void *load_block(void *file, long offset, long length)
  75 {
  76   void * dest = malloc(length);
  77   fseek(file, offset, SEEK_SET);
  78   fread(dest, (size_t)length, 1, file);
  79   return dest;
  80 }
  81
  82 static void free_block(void * block)
  83 {
  84   free(block);
  85 }
  86
  87
  88 /*
  89  * Test for correct ELF header here
  90  */
  91 static int check_header(struct elfheader *eh)
  92 {
  93   if
  94     (
  95          eh->ident[0] != 0x7f ||
  96          eh->ident[1] != 'E'  ||
  97          eh->ident[2] != 'L'  ||
  98          eh->ident[3] != 'F'
  99          )
 100   {
 101         D(kprintf("[ELF Loader] Not an ELF object\n"));
 102         return 0;
 103   }
 104
 105   if (eh->type != ET_REL || eh->machine != EM_386)
 106   {
 107         D(kprintf("[ELF Loader] Wrong object type or wrong architecture\n"));
 108         return 0;
 109   }
 110   return 1;
 111 }
 112
 113 /*
 114  * Get the memory for chunk and load it
 115  */
 116 static int load_hunk(void *file, struct sheader *sh)
 117 {
 118   void *ptr=(void*)0;
 119
 120   /* empty chunk? Who cares :) */
 121   if (!sh->size)
 122         return 1;
 123
 124
 125
 126   /* Allocate a chunk with write access - take aligned memory beneath the RO kernel */
 127   if (sh->flags & SHF_WRITE)
 128   {
 129         D(kprintf("[ELF Loader] RW chunk (%d bytes, align=%d) @ ", (unsigned int)sh->size, (unsigned int)sh->addralign));
 130 #if 1
 131         ptr = (void*)(((unsigned long)ptr_rw - (unsigned long)sh->size - (unsigned long)sh->addralign + 1) & ~((unsigned long)sh->addralign-1));
 132         ptr_rw = ptr;
 133 #else
 134         ptr = malloc(sh->size + sh->addralign);
 135 #endif
 136   }
 137   else
 138   {
 139         /* Read-Only mode? Get the memory from the kernel space, align it accorting to the demand */
 140 #if 1
 141         D(kprintf("[ELF Loader] RO chunk (%d bytes, align=%d) @ ", (unsigned int)sh->size, (unsigned int)sh->addralign));
 142         ptr_ro = (char *)(((unsigned long)ptr_ro + (unsigned long)sh->addralign - 1) & ~((unsigned long)sh->addralign-1));
 143         ptr = ptr_ro;
 144         ptr_ro = ptr_ro + sh->size;
 145 #else
 146         ptr = malloc(sh->size + sh->addralign);
 147 #endif
 148   }
 149   D(kprintf("%p\n", (unsigned int)ptr));
 150
 151   sh->addr = ptr;
 152
 153   /* copy block of memory from ELF file if it exists */
 154   if (sh->type != SHT_NOBITS)
 155         return read_block(file, sh->offset, (void *)((unsigned long)sh->addr), sh->size);
 156   else
 157   {
 158         bzero(ptr, sh->size);
 159         bss_tracker->addr = (unsigned long)ptr;
 160         bss_tracker->len = sh->size;
 161         bss_tracker++;
 162   }
 163
 164   return 1;
 165 }
 166
 167 /* Perform relocations of given section */
 168 static int relocate(struct elfheader *eh, struct sheader *sh, long shrel_idx, unsigned long long virt)
 169 {
 170   struct sheader *shrel    = &sh[shrel_idx];
 171   struct sheader *shsymtab = &sh[shrel->link];
 172   struct sheader *toreloc  = &sh[shrel->info];
 173
 174   struct symbol *symtab   = (struct symbol *)((unsigned long)shsymtab->addr);
 175   struct relo   *rel      = (struct relo *)((unsigned long)shrel->addr);
 176   char          *section  = (char *)((unsigned long)toreloc->addr);
 177
 178   unsigned int numrel = (unsigned long)shrel->size / (unsigned long)shrel->entsize;
 179   unsigned int i;
 180
 181   struct symbol *SysBase_sym = (void*)0;
 182
 183   D(kprintf("[ELF Loader] performing %d relocations, target address %p%p\n",
 184                         numrel, (unsigned long)(virt >> 32), (unsigned long)virt));
 185
 186   for (i=0; i<numrel; i++, rel++)
 187   {
 188         struct symbol *sym = &symtab[ELF32_R_SYM(rel->info)];
 189         unsigned long *p = (unsigned long *)&section[rel->offset];
 190         unsigned long long  s;
 191         const char * name = (char *)((unsigned long)sh[shsymtab->link].addr) + sym->name;
 192         switch (sym->shindex)
 193         {
 194           case SHN_UNDEF:
 195                 D(kprintf("[ELF Loader] Undefined symbol '%s' while relocating the section '%s'\n",
 196                                   (char *)((unsigned long)sh[shsymtab->link].addr) + sym->name,
 197                                   (char *)((unsigned long)sh[eh->shstrndx].addr) + toreloc->name));
 198                 return 0;
 199
 200           case SHN_COMMON:
 201                 D(kprintf("[ELF Loader] COMMON symbol '%s' while relocating the section '%s'\n",
 202                                   (char *)((unsigned long)sh[shsymtab->link].addr) + sym->name,
 203                                   (char *)((unsigned long)sh[eh->shstrndx].addr) + toreloc->name));
 204
 205                 return 0;
 206
 207           case SHN_ABS:
 208                 if (SysBase_sym == (void*)0)
 209                 {
 210                   if (strncmp(name, "SysBase", 8) == 0)
 211                   {
 212                         D(kprintf("[ELF Loader] got SysBase\n"));
 213                         SysBase_sym = sym;
 214                         goto SysBase_yes;
 215                   }
 216                   else
 217                         goto SysBase_no;
 218                 }
 219                 else
 220                   if (SysBase_sym == sym)
 221                   {
 222                   SysBase_yes: s = SysBaseAddr;
 223                   }
 224                   else
 225                         SysBase_no:  s = sym->value;
 226                 break;
 227
 228                 default:
 229                 s = (unsigned long)sh[sym->shindex].addr + virt + sym->value;
 230         }
 231
 232         s+=virt;
 233
 234         switch (ELF32_R_TYPE(rel->info))
 235         {
 236           case R_386_32: /* 32bit absolute */
 237                 *p += s;
 238                 break;
 239
 240           case R_386_PC32: /* 32bit PC relative */
 241                 *p += s - (unsigned int)p;
 242                 break;
 243
 244           case R_386_NONE:
 245                 break;
 246
 247           default:
 248                 kprintf("[ELF Loader] Unrecognized relocation type %d %d\n", i, (unsigned int)ELF32_R_TYPE(rel->info));
 249                 return 0;
 250         }
 251         if (sym->name)
 252           D(kprintf("[ELF Loader] relocated symbol: %s->0x%x\n",name,*p));
 253   }
 254   return 1;
 255 }
 256
 257 void load_elf_file(void *file, unsigned long long virt)
 258 {
 259   struct elfheader eh;
 260   struct sheader *sh;
 261   long i;
 262   int addr_displayed = 0;
 263
 264   D(kprintf("[ELF Loader] Loading ELF module from address %p\n", (unsigned int)file));
 265
 266   /* Check the header of ELF file */
 267   if
 268     (
 269          !read_block(file, 0, &eh, sizeof(eh)) ||
 270          !check_header(&eh) ||
 271          !(sh = load_block(file, eh.shoff, eh.shnum * eh.shentsize))
 272          )
 273   {
 274         kprintf("[ELF Loader] Wrong module header, aborting.\n");
 275         return;
 276   }
 277
 278   /* Iterate over the section header in order to prepare memory and eventually load some hunks */
 279   for (i=0; i < eh.shnum; i++)
 280   {
 281         /* Load the symbol and string tables */
 282         if (sh[i].type == SHT_SYMTAB || sh[i].type == SHT_STRTAB)
 283         {
 284           sh[i].addr = load_block(file, sh[i].offset, sh[i].size);
 285         }
 286         /* Does the section require memoy allcation? */
 287         else if (sh[i].flags & SHF_ALLOC)
 288         {
 289           /* Yup, it does. Load the hunk */
 290           if (!load_hunk(file, &sh[i]))
 291           {
 292                 kprintf("[ELF Loader] Error at loading of the hunk!\n");
 293           }
 294           else if (!addr_displayed)
 295           {
 296                 kprintf("[ELF Loader] shared mem@0x%x\n", sh[i].addr);
 297                 addr_displayed = 1;
 298           }
 299         }
 300   }
 301
 302   /* For every loaded section perform the relocations */
 303   for (i=0; i < eh.shnum; i++)
 304   {
 305         if ((sh[i].type == SHT_RELA || sh[i].type == SHT_REL) && sh[sh[i].info].addr)
 306         {
 307           sh[i].addr = load_block(file, sh[i].offset, sh[i].size);
 308           if (!sh[i].addr || !relocate(&eh, sh, i, virt))
 309           {
 310                 kprintf("[ELF Loader] Relocation error!\n");
 311           }
 312           free_block(sh[i].addr);
 313         }
 314         else if (sh[i].type == SHT_SYMTAB || sh[i].type == SHT_STRTAB)
 315           free_block(sh[i].addr);
 316   }
 317   free_block(sh);
 318 }
 319