src/system/runtime_loader/elf_load_image.cpp

   1 /*
   2  * Copyright 2008-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
   3  * Copyright 2003-2012, Axel Dörfler, axeld@pinc-software.de.
   4  * Distributed under the terms of the MIT License.
   5  *
   6  * Copyright 2002, Manuel J. Petit. All rights reserved.
   7  * Copyright 2001, Travis Geiselbrecht. All rights reserved.
   8  * Distributed under the terms of the NewOS License.
   9  */
  10
  11 #include "elf_load_image.h"
  12
  13 #include <stdio.h>
  14 #include <string.h>
  15
  16 #include <syscalls.h>
  17
  18 #include "add_ons.h"
  19 #include "elf_haiku_version.h"
  20 #include "elf_symbol_lookup.h"
  21 #include "elf_tls.h"
  22 #include "elf_versioning.h"
  23 #include "images.h"
  24 #include "runtime_loader_private.h"
  25
  26
  27 static const char* sSearchPathSubDir = NULL;
  28
  29
  30 static const char*
  31 get_program_path()
  32 {
  33         return gProgramImage != NULL ? gProgramImage->path : NULL;
  34 }
  35
  36
  37 static int32
  38 count_regions(const char* imagePath, char const* buff, int phnum, int phentsize)
  39 {
  40         elf_phdr* pheaders;
  41         int32 count = 0;
  42         int i;
  43
  44         for (i = 0; i < phnum; i++) {
  45                 pheaders = (elf_phdr*)(buff + i * phentsize);
  46
  47                 switch (pheaders->p_type) {
  48                         case PT_NULL:
  49                                 // NOP header
  50                                 break;
  51                         case PT_LOAD:
  52                                 count += 1;
  53                                 if (pheaders->p_memsz != pheaders->p_filesz) {
  54                                         addr_t A = TO_PAGE_SIZE(pheaders->p_vaddr
  55                                                 + pheaders->p_memsz);
  56                                         addr_t B = TO_PAGE_SIZE(pheaders->p_vaddr
  57                                                 + pheaders->p_filesz);
  58
  59                                         if (A != B)
  60                                                 count += 1;
  61                                 }
  62                                 break;
  63                         case PT_DYNAMIC:
  64                                 // will be handled at some other place
  65                                 break;
  66                         case PT_INTERP:
  67                                 // should check here for appropriate interpreter
  68                                 break;
  69                         case PT_NOTE:
  70                                 // unsupported
  71                                 break;
  72                         case PT_SHLIB:
  73                                 // undefined semantics
  74                                 break;
  75                         case PT_PHDR:
  76                                 // we don't use it
  77                                 break;
  78                         case PT_RELRO:
  79                                 // not implemented yet, but can be ignored
  80                                 break;
  81                         case PT_STACK:
  82                                 // we don't use it
  83                                 break;
  84                         case PT_TLS:
  85                                 // will be handled at some other place
  86                                 break;
  87                         default:
  88                                 FATAL("%s: Unhandled pheader type in count 0x%" B_PRIx32 "\n",
  89                                         imagePath, pheaders->p_type);
  90                                 break;
  91                 }
  92         }
  93
  94         return count;
  95 }
  96
  97
  98 static status_t
  99 parse_program_headers(image_t* image, char* buff, int phnum, int phentsize)
 100 {
 101         elf_phdr* pheader;
 102         int regcount;
 103         int i;
 104
 105         image->dso_tls_id = unsigned(-1);
 106
 107         regcount = 0;
 108         for (i = 0; i < phnum; i++) {
 109                 pheader = (elf_phdr*)(buff + i * phentsize);
 110
 111                 switch (pheader->p_type) {
 112                         case PT_NULL:
 113                                 /* NOP header */
 114                                 break;
 115                         case PT_LOAD:
 116                                 if (pheader->p_memsz == pheader->p_filesz) {
 117                                         /*
 118                                          * everything in one area
 119                                          */
 120                                         image->regions[regcount].start = pheader->p_vaddr;
 121                                         image->regions[regcount].size = pheader->p_memsz;
 122                                         image->regions[regcount].vmstart
 123                                                 = PAGE_BASE(pheader->p_vaddr);
 124                                         image->regions[regcount].vmsize
 125                                                 = TO_PAGE_SIZE(pheader->p_memsz
 126                                                         + PAGE_OFFSET(pheader->p_vaddr));
 127                                         image->regions[regcount].fdstart = pheader->p_offset;
 128                                         image->regions[regcount].fdsize = pheader->p_filesz;
 129                                         image->regions[regcount].delta = 0;
 130                                         image->regions[regcount].flags = 0;
 131                                         if (pheader->p_flags & PF_WRITE) {
 132                                                 // this is a writable segment
 133                                                 image->regions[regcount].flags |= RFLAG_RW;
 134                                         }
 135                                 } else {
 136                                         /*
 137                                          * may require splitting
 138                                          */
 139                                         addr_t A = TO_PAGE_SIZE(pheader->p_vaddr
 140                                                 + pheader->p_memsz);
 141                                         addr_t B = TO_PAGE_SIZE(pheader->p_vaddr
 142                                                 + pheader->p_filesz);
 143
 144                                         image->regions[regcount].start = pheader->p_vaddr;
 145                                         image->regions[regcount].size = pheader->p_filesz;
 146                                         image->regions[regcount].vmstart
 147                                                 = PAGE_BASE(pheader->p_vaddr);
 148                                         image->regions[regcount].vmsize
 149                                                 = TO_PAGE_SIZE(pheader->p_filesz
 150                                                         + PAGE_OFFSET(pheader->p_vaddr));
 151                                         image->regions[regcount].fdstart = pheader->p_offset;
 152                                         image->regions[regcount].fdsize = pheader->p_filesz;
 153                                         image->regions[regcount].delta = 0;
 154                                         image->regions[regcount].flags = 0;
 155                                         if (pheader->p_flags & PF_WRITE) {
 156                                                 // this is a writable segment
 157                                                 image->regions[regcount].flags |= RFLAG_RW;
 158                                         }
 159
 160                                         if (A != B) {
 161                                                 /*
 162                                                  * yeah, it requires splitting
 163                                                  */
 164                                                 regcount += 1;
 165                                                 image->regions[regcount].start = pheader->p_vaddr;
 166                                                 image->regions[regcount].size
 167                                                         = pheader->p_memsz - pheader->p_filesz;
 168                                                 image->regions[regcount].vmstart
 169                                                         = image->regions[regcount-1].vmstart
 170                                                                 + image->regions[regcount-1].vmsize;
 171                                                 image->regions[regcount].vmsize
 172                                                         = TO_PAGE_SIZE(pheader->p_memsz
 173                                                                         + PAGE_OFFSET(pheader->p_vaddr))
 174                                                                 - image->regions[regcount-1].vmsize;
 175                                                 image->regions[regcount].fdstart = 0;
 176                                                 image->regions[regcount].fdsize = 0;
 177                                                 image->regions[regcount].delta = 0;
 178                                                 image->regions[regcount].flags = RFLAG_ANON;
 179                                                 if (pheader->p_flags & PF_WRITE) {
 180                                                         // this is a writable segment
 181                                                         image->regions[regcount].flags |= RFLAG_RW;
 182                                                 }
 183                                         }
 184                                 }
 185                                 regcount += 1;
 186                                 break;
 187                         case PT_DYNAMIC:
 188                                 image->dynamic_ptr = pheader->p_vaddr;
 189                                 break;
 190                         case PT_INTERP:
 191                                 // should check here for appropiate interpreter
 192                                 break;
 193                         case PT_NOTE:
 194                                 // unsupported
 195                                 break;
 196                         case PT_SHLIB:
 197                                 // undefined semantics
 198                                 break;
 199                         case PT_PHDR:
 200                                 // we don't use it
 201                                 break;
 202                         case PT_RELRO:
 203                                 // not implemented yet, but can be ignored
 204                                 break;
 205                         case PT_STACK:
 206                                 // we don't use it
 207                                 break;
 208                         case PT_TLS:
 209                                 image->dso_tls_id
 210                                         = TLSBlockTemplates::Get().Register(
 211                                                 TLSBlockTemplate((void*)pheader->p_vaddr,
 212                                                         pheader->p_filesz, pheader->p_memsz));
 213                                 break;
 214                         default:
 215                                 FATAL("%s: Unhandled pheader type in parse 0x%" B_PRIx32 "\n",
 216                                         image->path, pheader->p_type);
 217                                 return B_BAD_DATA;
 218                 }
 219         }
 220
 221         return B_OK;
 222 }
 223
 224
 225 static bool
 226 assert_dynamic_loadable(image_t* image)
 227 {
 228         uint32 i;
 229
 230         if (!image->dynamic_ptr)
 231                 return true;
 232
 233         for (i = 0; i < image->num_regions; i++) {
 234                 if (image->dynamic_ptr >= image->regions[i].start
 235                         && image->dynamic_ptr
 236                                 < image->regions[i].start + image->regions[i].size) {
 237                         return true;
 238                 }
 239         }
 240
 241         return false;
 242 }
 243
 244
 245 static bool
 246 parse_dynamic_segment(image_t* image)
 247 {
 248         elf_dyn* d;
 249         int i;
 250         int sonameOffset = -1;
 251
 252         image->symhash = 0;
 253         image->syms = 0;
 254         image->strtab = 0;
 255
 256         d = (elf_dyn*)image->dynamic_ptr;
 257         if (!d)
 258                 return true;
 259
 260         for (i = 0; d[i].d_tag != DT_NULL; i++) {
 261                 switch (d[i].d_tag) {
 262                         case DT_NEEDED:
 263                                 image->num_needed += 1;
 264                                 break;
 265                         case DT_HASH:
 266                                 image->symhash
 267                                         = (uint32*)(d[i].d_un.d_ptr + image->regions[0].delta);
 268                                 break;
 269                         case DT_STRTAB:
 270                                 image->strtab
 271                                         = (char*)(d[i].d_un.d_ptr + image->regions[0].delta);
 272                                 break;
 273                         case DT_SYMTAB:
 274                                 image->syms = (elf_sym*)
 275                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 276                                 break;
 277                         case DT_REL:
 278                                 image->rel = (elf_rel*)
 279                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 280                                 break;
 281                         case DT_RELSZ:
 282                                 image->rel_len = d[i].d_un.d_val;
 283                                 break;
 284                         case DT_RELA:
 285                                 image->rela = (elf_rela*)
 286                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 287                                 break;
 288                         case DT_RELASZ:
 289                                 image->rela_len = d[i].d_un.d_val;
 290                                 break;
 291                         case DT_JMPREL:
 292                                 // procedure linkage table relocations
 293                                 image->pltrel = (elf_rel*)
 294                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 295                                 break;
 296                         case DT_PLTRELSZ:
 297                                 image->pltrel_len = d[i].d_un.d_val;
 298                                 break;
 299                         case DT_INIT:
 300                                 image->init_routine
 301                                         = (d[i].d_un.d_ptr + image->regions[0].delta);
 302                                 break;
 303                         case DT_FINI:
 304                                 image->term_routine
 305                                         = (d[i].d_un.d_ptr + image->regions[0].delta);
 306                                 break;
 307                         case DT_SONAME:
 308                                 sonameOffset = d[i].d_un.d_val;
 309                                 break;
 310                         case DT_VERSYM:
 311                                 image->symbol_versions = (elf_versym*)
 312                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 313                                 break;
 314                         case DT_VERDEF:
 315                                 image->version_definitions = (elf_verdef*)
 316                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 317                                 break;
 318                         case DT_VERDEFNUM:
 319                                 image->num_version_definitions = d[i].d_un.d_val;
 320                                 break;
 321                         case DT_VERNEED:
 322                                 image->needed_versions = (elf_verneed*)
 323                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 324                                 break;
 325                         case DT_VERNEEDNUM:
 326                                 image->num_needed_versions = d[i].d_un.d_val;
 327                                 break;
 328                         case DT_SYMBOLIC:
 329                                 image->flags |= RFLAG_SYMBOLIC;
 330                                 break;
 331                         case DT_FLAGS:
 332                         {
 333                                 uint32 flags = d[i].d_un.d_val;
 334                                 if ((flags & DF_SYMBOLIC) != 0)
 335                                         image->flags |= RFLAG_SYMBOLIC;
 336                                 if ((flags & DF_STATIC_TLS) != 0) {
 337                                         FATAL("Static TLS model is not supported.\n");
 338                                         return false;
 339                                 }
 340                                 break;
 341                         }
 342                         case DT_INIT_ARRAY:
 343                                 // array of pointers to initialization functions
 344                                 image->init_array = (addr_t*)
 345                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 346                                 break;
 347                         case DT_INIT_ARRAYSZ:
 348                                 // size in bytes of the array of initialization functions
 349                                 image->init_array_len = d[i].d_un.d_val;
 350                                 break;
 351                         case DT_PREINIT_ARRAY:
 352                                 // array of pointers to pre-initialization functions
 353                                 image->preinit_array = (addr_t*)
 354                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 355                                 break;
 356                         case DT_PREINIT_ARRAYSZ:
 357                                 // size in bytes of the array of pre-initialization functions
 358                                 image->preinit_array_len = d[i].d_un.d_val;
 359                                 break;
 360                         case DT_FINI_ARRAY:
 361                                 // array of pointers to termination functions
 362                                 image->term_array = (addr_t*)
 363                                         (d[i].d_un.d_ptr + image->regions[0].delta);
 364                                 break;
 365                         case DT_FINI_ARRAYSZ:
 366                                 // size in bytes of the array of termination functions
 367                                 image->term_array_len = d[i].d_un.d_val;
 368                                 break;
 369                         default:
 370                                 continue;
 371
 372                         // TODO: Implement:
 373                         // DT_RELENT: The size of a DT_REL entry.
 374                         // DT_RELAENT: The size of a DT_RELA entry.
 375                         // DT_SYMENT: The size of a symbol table entry.
 376                         // DT_PLTREL: The type of the PLT relocation entries (DT_JMPREL).
 377                         // DT_BIND_NOW/DF_BIND_NOW: No lazy binding allowed.
 378                         // DT_RUNPATH: Library search path (supersedes DT_RPATH).
 379                         // DT_TEXTREL/DF_TEXTREL: Indicates whether text relocations are
 380                         //              required (for optimization purposes only).
 381                 }
 382         }
 383
 384         // lets make sure we found all the required sections
 385         if (!image->symhash || !image->syms || !image->strtab)
 386                 return false;
 387
 388         if (sonameOffset >= 0)
 389                 strlcpy(image->name, STRING(image, sonameOffset), sizeof(image->name));
 390
 391         return true;
 392 }
 393
 394
 395 // #pragma mark -
 396
 397
 398 status_t
 399 parse_elf_header(elf_ehdr* eheader, int32* _pheaderSize,
 400         int32* _sheaderSize)
 401 {
 402         if (memcmp(eheader->e_ident, ELFMAG, 4) != 0)
 403                 return B_NOT_AN_EXECUTABLE;
 404
 405         if (eheader->e_ident[4] != ELF_CLASS)
 406                 return B_NOT_AN_EXECUTABLE;
 407
 408         if (eheader->e_phoff == 0)
 409                 return B_NOT_AN_EXECUTABLE;
 410
 411         if (eheader->e_phentsize < sizeof(elf_phdr))
 412                 return B_NOT_AN_EXECUTABLE;
 413
 414         *_pheaderSize = eheader->e_phentsize * eheader->e_phnum;
 415         *_sheaderSize = eheader->e_shentsize * eheader->e_shnum;
 416
 417         if (*_pheaderSize <= 0 || *_sheaderSize <= 0)
 418                 return B_NOT_AN_EXECUTABLE;
 419
 420         return B_OK;
 421 }
 422
 423
 424 status_t
 425 load_image(char const* name, image_type type, const char* rpath,
 426         const char* requestingObjectPath, image_t** _image)
 427 {
 428         int32 pheaderSize, sheaderSize;
 429         char path[PATH_MAX];
 430         ssize_t length;
 431         char pheaderBuffer[4096];
 432         int32 numRegions;
 433         image_t* found;
 434         image_t* image;
 435         status_t status;
 436         int fd;
 437
 438         elf_ehdr eheader;
 439
 440         // Have we already loaded that image? Don't check for add-ons -- we always
 441         // reload them.
 442         if (type != B_ADD_ON_IMAGE) {
 443                 found = find_loaded_image_by_name(name, APP_OR_LIBRARY_TYPE);
 444
 445                 if (found == NULL && type != B_APP_IMAGE && gProgramImage != NULL) {
 446                         // Special case for add-ons that link against the application
 447                         // executable, with the executable not having a soname set.
 448                         if (const char* lastSlash = strrchr(name, '/')) {
 449                                 if (strcmp(gProgramImage->name, lastSlash + 1) == 0)
 450                                         found = gProgramImage;
 451                         }
 452                 }
 453
 454                 if (found) {
 455                         atomic_add(&found->ref_count, 1);
 456                         *_image = found;
 457                         KTRACE("rld: load_container(\"%s\", type: %d, rpath: \"%s\") "
 458                                 "already loaded", name, type, rpath);
 459                         return B_OK;
 460                 }
 461         }
 462
 463         KTRACE("rld: load_container(\"%s\", type: %d, rpath: \"%s\")", name, type,
 464                 rpath);
 465
 466         strlcpy(path, name, sizeof(path));
 467
 468         // find and open the file
 469         fd = open_executable(path, type, rpath, get_program_path(),
 470                 requestingObjectPath, sSearchPathSubDir);
 471         if (fd < 0) {
 472                 FATAL("Cannot open file %s: %s\n", name, strerror(fd));
 473                 KTRACE("rld: load_container(\"%s\"): failed to open file", name);
 474                 return fd;
 475         }
 476
 477         // normalize the image path
 478         status = _kern_normalize_path(path, true, path);
 479         if (status != B_OK)
 480                 goto err1;
 481
 482         // Test again if this image has been registered already - this time,
 483         // we can check the full path, not just its name as noted.
 484         // You could end up loading an image twice with symbolic links, else.
 485         if (type != B_ADD_ON_IMAGE) {
 486                 found = find_loaded_image_by_name(path, APP_OR_LIBRARY_TYPE);
 487                 if (found) {
 488                         atomic_add(&found->ref_count, 1);
 489                         *_image = found;
 490                         _kern_close(fd);
 491                         KTRACE("rld: load_container(\"%s\"): already loaded after all",
 492                                 name);
 493                         return B_OK;
 494                 }
 495         }
 496
 497         length = _kern_read(fd, 0, &eheader, sizeof(eheader));
 498         if (length != sizeof(eheader)) {
 499                 status = B_NOT_AN_EXECUTABLE;
 500                 FATAL("%s: Troubles reading ELF header\n", path);
 501                 goto err1;
 502         }
 503
 504         status = parse_elf_header(&eheader, &pheaderSize, &sheaderSize);
 505         if (status < B_OK) {
 506                 FATAL("%s: Incorrect ELF header\n", path);
 507                 goto err1;
 508         }
 509
 510         // ToDo: what to do about this restriction??
 511         if (pheaderSize > (int)sizeof(pheaderBuffer)) {
 512                 FATAL("%s: Cannot handle program headers bigger than %lu\n",
 513                         path, sizeof(pheaderBuffer));
 514                 status = B_UNSUPPORTED;
 515                 goto err1;
 516         }
 517
 518         length = _kern_read(fd, eheader.e_phoff, pheaderBuffer, pheaderSize);
 519         if (length != pheaderSize) {
 520                 FATAL("%s: Could not read program headers: %s\n", path,
 521                         strerror(length));
 522                 status = B_BAD_DATA;
 523                 goto err1;
 524         }
 525
 526         numRegions = count_regions(path, pheaderBuffer, eheader.e_phnum,
 527                 eheader.e_phentsize);
 528         if (numRegions <= 0) {
 529                 FATAL("%s: Troubles parsing Program headers, numRegions = %" B_PRId32
 530                         "\n", path, numRegions);
 531                 status = B_BAD_DATA;
 532                 goto err1;
 533         }
 534
 535         image = create_image(name, path, numRegions);
 536         if (image == NULL) {
 537                 FATAL("%s: Failed to allocate image_t object\n", path);
 538                 status = B_NO_MEMORY;
 539                 goto err1;
 540         }
 541
 542         status = parse_program_headers(image, pheaderBuffer, eheader.e_phnum,
 543                 eheader.e_phentsize);
 544         if (status < B_OK)
 545                 goto err2;
 546
 547         if (!assert_dynamic_loadable(image)) {
 548                 FATAL("%s: Dynamic segment must be loadable (implementation "
 549                         "restriction)\n", image->path);
 550                 status = B_UNSUPPORTED;
 551                 goto err2;
 552         }
 553
 554         status = map_image(fd, path, image, eheader.e_type == ET_EXEC);
 555         if (status < B_OK) {
 556                 FATAL("%s: Could not map image: %s\n", image->path, strerror(status));
 557                 status = B_ERROR;
 558                 goto err2;
 559         }
 560
 561         if (!parse_dynamic_segment(image)) {
 562                 FATAL("%s: Troubles handling dynamic section\n", image->path);
 563                 status = B_BAD_DATA;
 564                 goto err3;
 565         }
 566
 567         if (eheader.e_entry != 0)
 568                 image->entry_point = eheader.e_entry + image->regions[0].delta;
 569
 570         analyze_image_haiku_version_and_abi(fd, image, eheader, sheaderSize,
 571                 pheaderBuffer, sizeof(pheaderBuffer));
 572
 573         // If sSearchPathSubDir is unset (meaning, this is the first image we're
 574         // loading) we init the search path subdir if the compiler version doesn't
 575         // match ours.
 576         if (sSearchPathSubDir == NULL) {
 577                 #if __GNUC__ == 2
 578                         if ((image->abi & B_HAIKU_ABI_MAJOR) == B_HAIKU_ABI_GCC_4)
 579                                 sSearchPathSubDir = "x86";
 580                 #elif __GNUC__ >= 4
 581                         if ((image->abi & B_HAIKU_ABI_MAJOR) == B_HAIKU_ABI_GCC_2)
 582                                 sSearchPathSubDir = "x86_gcc2";
 583                 #endif
 584         }
 585
 586         set_abi_version(image->abi);
 587
 588         // init gcc version dependent image flags
 589         // symbol resolution strategy
 590         if (image->abi == B_HAIKU_ABI_GCC_2_ANCIENT)
 591                 image->find_undefined_symbol = find_undefined_symbol_beos;
 592
 593         // init version infos
 594         status = init_image_version_infos(image);
 595
 596         image->type = type;
 597         register_image(image, fd, path);
 598         image_event(image, IMAGE_EVENT_LOADED);
 599
 600         _kern_close(fd);
 601
 602         enqueue_loaded_image(image);
 603
 604         *_image = image;
 605
 606         KTRACE("rld: load_container(\"%s\"): done: id: %" B_PRId32 " (ABI: %#"
 607                 B_PRIx32 ")", name, image->id, image->abi);
 608
 609         return B_OK;
 610
 611 err3:
 612         unmap_image(image);
 613 err2:
 614         delete_image_struct(image);
 615 err1:
 616         _kern_close(fd);
 617
 618         KTRACE("rld: load_container(\"%s\"): failed: %s", name,
 619                 strerror(status));
 620
 621         return status;
 622 }