sys/lib/libsa/loadfile_elf32.c

   1 /* $NetBSD: loadfile_elf32.c,v 1.23 2008/05/20 14:41:06 ad Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1997, 2008 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
   9  * NASA Ames Research Center and by Christos Zoulas.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /* If not included by exec_elf64.c, ELFSIZE won't be defined. */
  34 #ifndef ELFSIZE
  35 #define ELFSIZE 32
  36 #endif
  37
  38 #ifdef _STANDALONE
  39 #include <lib/libsa/stand.h>
  40 #include <lib/libkern/libkern.h>
  41 #else
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <errno.h>
  45 #include <stdlib.h>
  46 #include <unistd.h>
  47 #include <fcntl.h>
  48 #include <err.h>
  49 #endif
  50
  51 #include <sys/param.h>
  52 #include <sys/exec.h>
  53
  54 #include "loadfile.h"
  55
  56 #if ((ELFSIZE == 32) && defined(BOOT_ELF32)) || \
  57     ((ELFSIZE == 64) && defined(BOOT_ELF64))
  58
  59 #define ELFROUND        (ELFSIZE / 8)
  60
  61 #ifndef _STANDALONE
  62 #include "byteorder.h"
  63
  64 /*
  65  * Byte swapping may be necessary in the non-_STANDLONE case because
  66  * we may be built with a host compiler.
  67  */
  68 #define E16(f)                                                          \
  69         f = (bo == ELFDATA2LSB) ? sa_htole16(f) : sa_htobe16(f)
  70 #define E32(f)                                                          \
  71         f = (bo == ELFDATA2LSB) ? sa_htole32(f) : sa_htobe32(f)
  72 #define E64(f)                                                          \
  73         f = (bo == ELFDATA2LSB) ? sa_htole64(f) : sa_htobe64(f)
  74
  75 #define I16(f)                                                          \
  76         f = (bo == ELFDATA2LSB) ? sa_le16toh(f) : sa_be16toh(f)
  77 #define I32(f)                                                          \
  78         f = (bo == ELFDATA2LSB) ? sa_le32toh(f) : sa_be32toh(f)
  79 #define I64(f)                                                          \
  80         f = (bo == ELFDATA2LSB) ? sa_le64toh(f) : sa_be64toh(f)
  81
  82 static void
  83 internalize_ehdr(Elf_Byte bo, Elf_Ehdr *ehdr)
  84 {
  85
  86 #if ELFSIZE == 32
  87         I16(ehdr->e_type);
  88         I16(ehdr->e_machine);
  89         I32(ehdr->e_version);
  90         I32(ehdr->e_entry);
  91         I32(ehdr->e_phoff);
  92         I32(ehdr->e_shoff);
  93         I32(ehdr->e_flags);
  94         I16(ehdr->e_ehsize);
  95         I16(ehdr->e_phentsize);
  96         I16(ehdr->e_phnum);
  97         I16(ehdr->e_shentsize);
  98         I16(ehdr->e_shnum);
  99         I16(ehdr->e_shstrndx);
 100 #elif ELFSIZE == 64
 101         I16(ehdr->e_type);
 102         I16(ehdr->e_machine);
 103         I32(ehdr->e_version);
 104         I64(ehdr->e_entry);
 105         I64(ehdr->e_phoff);
 106         I64(ehdr->e_shoff);
 107         I32(ehdr->e_flags);
 108         I16(ehdr->e_ehsize);
 109         I16(ehdr->e_phentsize);
 110         I16(ehdr->e_phnum);
 111         I16(ehdr->e_shentsize);
 112         I16(ehdr->e_shnum);
 113         I16(ehdr->e_shstrndx);
 114 #else
 115 #error ELFSIZE is not 32 or 64
 116 #endif
 117 }
 118
 119 static void
 120 externalize_ehdr(Elf_Byte bo, Elf_Ehdr *ehdr)
 121 {
 122
 123 #if ELFSIZE == 32
 124         E16(ehdr->e_type);
 125         E16(ehdr->e_machine);
 126         E32(ehdr->e_version);
 127         E32(ehdr->e_entry);
 128         E32(ehdr->e_phoff);
 129         E32(ehdr->e_shoff);
 130         E32(ehdr->e_flags);
 131         E16(ehdr->e_ehsize);
 132         E16(ehdr->e_phentsize);
 133         E16(ehdr->e_phnum);
 134         E16(ehdr->e_shentsize);
 135         E16(ehdr->e_shnum);
 136         E16(ehdr->e_shstrndx);
 137 #elif ELFSIZE == 64
 138         E16(ehdr->e_type);
 139         E16(ehdr->e_machine);
 140         E32(ehdr->e_version);
 141         E64(ehdr->e_entry);
 142         E64(ehdr->e_phoff);
 143         E64(ehdr->e_shoff);
 144         E32(ehdr->e_flags);
 145         E16(ehdr->e_ehsize);
 146         E16(ehdr->e_phentsize);
 147         E16(ehdr->e_phnum);
 148         E16(ehdr->e_shentsize);
 149         E16(ehdr->e_shnum);
 150         E16(ehdr->e_shstrndx);
 151 #else
 152 #error ELFSIZE is not 32 or 64
 153 #endif
 154 }
 155
 156 static void
 157 internalize_phdr(Elf_Byte bo, Elf_Phdr *phdr)
 158 {
 159
 160 #if ELFSIZE == 32
 161         I32(phdr->p_type);
 162         I32(phdr->p_offset);
 163         I32(phdr->p_vaddr);
 164         I32(phdr->p_paddr);
 165         I32(phdr->p_filesz);
 166         I32(phdr->p_memsz);
 167         I32(phdr->p_flags);
 168         I32(phdr->p_align);
 169 #elif ELFSIZE == 64
 170         I32(phdr->p_type);
 171         I32(phdr->p_offset);
 172         I64(phdr->p_vaddr);
 173         I64(phdr->p_paddr);
 174         I64(phdr->p_filesz);
 175         I64(phdr->p_memsz);
 176         I64(phdr->p_flags);
 177         I64(phdr->p_align);
 178 #else
 179 #error ELFSIZE is not 32 or 64
 180 #endif
 181 }
 182
 183 static void
 184 internalize_shdr(Elf_Byte bo, Elf_Shdr *shdr)
 185 {
 186
 187 #if ELFSIZE == 32
 188         I32(shdr->sh_name);
 189         I32(shdr->sh_type);
 190         I32(shdr->sh_flags);
 191         I32(shdr->sh_addr);
 192         I32(shdr->sh_offset);
 193         I32(shdr->sh_size);
 194         I32(shdr->sh_link);
 195         I32(shdr->sh_info);
 196         I32(shdr->sh_addralign);
 197         I32(shdr->sh_entsize);
 198 #elif ELFSIZE == 64
 199         I32(shdr->sh_name);
 200         I32(shdr->sh_type);
 201         I64(shdr->sh_flags);
 202         I64(shdr->sh_addr);
 203         I64(shdr->sh_offset);
 204         I64(shdr->sh_size);
 205         I32(shdr->sh_link);
 206         I32(shdr->sh_info);
 207         I64(shdr->sh_addralign);
 208         I64(shdr->sh_entsize);
 209 #else
 210 #error ELFSIZE is not 32 or 64
 211 #endif
 212 }
 213
 214 static void
 215 externalize_shdr(Elf_Byte bo, Elf_Shdr *shdr)
 216 {
 217
 218 #if ELFSIZE == 32
 219         E32(shdr->sh_name);
 220         E32(shdr->sh_type);
 221         E32(shdr->sh_flags);
 222         E32(shdr->sh_addr);
 223         E32(shdr->sh_offset);
 224         E32(shdr->sh_size);
 225         E32(shdr->sh_link);
 226         E32(shdr->sh_info);
 227         E32(shdr->sh_addralign);
 228         E32(shdr->sh_entsize);
 229 #elif ELFSIZE == 64
 230         E32(shdr->sh_name);
 231         E32(shdr->sh_type);
 232         E64(shdr->sh_flags);
 233         E64(shdr->sh_addr);
 234         E64(shdr->sh_offset);
 235         E64(shdr->sh_size);
 236         E32(shdr->sh_link);
 237         E32(shdr->sh_info);
 238         E64(shdr->sh_addralign);
 239         E64(shdr->sh_entsize);
 240 #else
 241 #error ELFSIZE is not 32 or 64
 242 #endif
 243 }
 244 #else /* _STANDALONE */
 245 /*
 246  * Byte swapping is never necessary in the _STANDALONE case because
 247  * we are being built with the target compiler.
 248  */
 249 #define internalize_ehdr(bo, ehdr)      /* nothing */
 250 #define externalize_ehdr(bo, ehdr)      /* nothing */
 251
 252 #define internalize_phdr(bo, phdr)      /* nothing */
 253
 254 #define internalize_shdr(bo, shdr)      /* nothing */
 255 #define externalize_shdr(bo, shdr)      /* nothing */
 256 #endif /* _STANDALONE */
 257
 258 int
 259 ELFNAMEEND(loadfile)(int fd, Elf_Ehdr *elf, u_long *marks, int flags)
 260 {
 261         Elf_Shdr *shp;
 262         Elf_Phdr *phdr;
 263         int i, j;
 264         ssize_t sz;
 265         int first;
 266         paddr_t minp = ~0, maxp = 0, pos = 0;
 267         paddr_t offset = marks[MARK_START], shpp, elfp = 0;
 268         ssize_t nr;
 269         struct __packed {
 270                 Elf_Nhdr        nh;
 271                 uint8_t         name[ELF_NOTE_NETBSD_NAMESZ + 1];
 272                 uint8_t         desc[ELF_NOTE_NETBSD_DESCSZ];
 273         } note;
 274
 275         /* some ports dont use the offset */
 276         offset = offset;
 277
 278         internalize_ehdr(elf->e_ident[EI_DATA], elf);
 279
 280         sz = elf->e_phnum * sizeof(Elf_Phdr);
 281         phdr = ALLOC(sz);
 282
 283         if (lseek(fd, elf->e_phoff, SEEK_SET) == -1)  {
 284                 WARN(("lseek phdr"));
 285                 goto freephdr;
 286         }
 287         nr = read(fd, phdr, sz);
 288         if (nr == -1) {
 289                 WARN(("read program headers"));
 290                 goto freephdr;
 291         }
 292         if (nr != sz) {
 293                 errno = EIO;
 294                 WARN(("read program headers"));
 295                 goto freephdr;
 296         }
 297
 298         for (first = 1, i = 0; i < elf->e_phnum; i++) {
 299                 internalize_phdr(elf->e_ident[EI_DATA], &phdr[i]);
 300
 301 #ifndef MD_LOADSEG /* Allow processor ABI specific segment loads */
 302 #define MD_LOADSEG(a) /*CONSTCOND*/0
 303 #endif
 304                 if (MD_LOADSEG(&phdr[i]))
 305                         goto loadseg;
 306
 307                 if (phdr[i].p_type != PT_LOAD ||
 308                     (phdr[i].p_flags & (PF_W|PF_X)) == 0)
 309                         continue;
 310
 311 #define IS_TEXT(p)      (p.p_flags & PF_X)
 312 #define IS_DATA(p)      (p.p_flags & PF_W)
 313 #define IS_BSS(p)       (p.p_filesz < p.p_memsz)
 314                 /*
 315                  * XXX: Assume first address is lowest
 316                  */
 317                 if ((IS_TEXT(phdr[i]) && (flags & LOAD_TEXT)) ||
 318                     (IS_DATA(phdr[i]) && (flags & LOAD_DATA))) {
 319
 320                 loadseg:
 321                         if (marks[MARK_DATA] == 0 && IS_DATA(phdr[i]))
 322                                 marks[MARK_DATA] = LOADADDR(phdr[i].p_vaddr);
 323
 324                         /* Read in segment. */
 325                         PROGRESS(("%s%lu", first ? "" : "+",
 326                             (u_long)phdr[i].p_filesz));
 327
 328                         if (lseek(fd, phdr[i].p_offset, SEEK_SET) == -1)  {
 329                                 WARN(("lseek text"));
 330                                 goto freephdr;
 331                         }
 332                         nr = READ(fd, phdr[i].p_vaddr, phdr[i].p_filesz);
 333                         if (nr == -1) {
 334                                 WARN(("read text error"));
 335                                 goto freephdr;
 336                         }
 337                         if (nr != (ssize_t)phdr[i].p_filesz) {
 338                                 errno = EIO;
 339                                 WARN(("read text"));
 340                                 goto freephdr;
 341                         }
 342                         first = 0;
 343
 344                 }
 345                 if ((IS_TEXT(phdr[i]) && (flags & (LOAD_TEXT|COUNT_TEXT))) ||
 346                     (IS_DATA(phdr[i]) && (flags & (LOAD_DATA|COUNT_TEXT)))) {
 347                         pos = phdr[i].p_vaddr;
 348                         if (minp > pos)
 349                                 minp = pos;
 350                         pos += phdr[i].p_filesz;
 351                         if (maxp < pos)
 352                                 maxp = pos;
 353                 }
 354
 355                 /* Zero out bss. */
 356                 if (IS_BSS(phdr[i]) && (flags & LOAD_BSS)) {
 357                         PROGRESS(("+%lu",
 358                             (u_long)(phdr[i].p_memsz - phdr[i].p_filesz)));
 359                         BZERO((phdr[i].p_vaddr + phdr[i].p_filesz),
 360                             phdr[i].p_memsz - phdr[i].p_filesz);
 361                 }
 362                 if (IS_BSS(phdr[i]) && (flags & (LOAD_BSS|COUNT_BSS))) {
 363                         pos += phdr[i].p_memsz - phdr[i].p_filesz;
 364                         if (maxp < pos)
 365                                 maxp = pos;
 366                 }
 367         }
 368         DEALLOC(phdr, sz);
 369
 370         /*
 371          * Copy the ELF and section headers.
 372          */
 373         maxp = roundup(maxp, ELFROUND);
 374         if (flags & (LOAD_HDR|COUNT_HDR)) {
 375                 elfp = maxp;
 376                 maxp += sizeof(Elf_Ehdr);
 377         }
 378
 379         if (flags & (LOAD_SYM|COUNT_SYM)) {
 380                 if (lseek(fd, elf->e_shoff, SEEK_SET) == -1)  {
 381                         WARN(("lseek section headers"));
 382                         return 1;
 383                 }
 384                 sz = elf->e_shnum * sizeof(Elf_Shdr);
 385
 386                 shp = ALLOC(sz);
 387
 388                 nr = read(fd, shp, sz);
 389                 if (nr == -1) {
 390                         WARN(("read section headers"));
 391                         goto freeshp;
 392                 }
 393                 if (nr != sz) {
 394                         errno = EIO;
 395                         WARN(("read section headers"));
 396                         goto freeshp;
 397                 }
 398
 399                 shpp = maxp;
 400                 maxp += roundup(sz, ELFROUND);
 401
 402 #ifndef _STANDALONE
 403                 /* Internalize the section headers. */
 404                 for (i = 0; i < elf->e_shnum; i++)
 405                         internalize_shdr(elf->e_ident[EI_DATA], &shp[i]);
 406 #endif /* ! _STANDALONE */
 407
 408                 /*
 409                  * Now load the symbol sections themselves.  Make sure
 410                  * the sections are aligned. Don't bother with any
 411                  * string table that isn't referenced by a symbol
 412                  * table.
 413                  */
 414                 for (first = 1, i = 0; i < elf->e_shnum; i++) {
 415                         switch (shp[i].sh_type) {
 416                         case SHT_STRTAB:
 417                                 for (j = 0; j < elf->e_shnum; j++)
 418                                         if (shp[j].sh_type == SHT_SYMTAB &&
 419                                             shp[j].sh_link == (unsigned int)i)
 420                                                 goto havesym;
 421                                 /* FALLTHROUGH */
 422                         default:
 423                                 /* Not loading this, so zero out the offset. */
 424                                 shp[i].sh_offset = 0;
 425                                 break;
 426                         havesym:
 427                         case SHT_SYMTAB:
 428                                 if (flags & LOAD_SYM) {
 429                                         PROGRESS(("%s%ld", first ? " [" : "+",
 430                                             (u_long)shp[i].sh_size));
 431                                         if (lseek(fd, shp[i].sh_offset,
 432                                             SEEK_SET) == -1) {
 433                                                 WARN(("lseek symbols"));
 434                                                 goto freeshp;
 435                                         }
 436                                         nr = READ(fd, maxp, shp[i].sh_size);
 437                                         if (nr == -1) {
 438                                                 WARN(("read symbols"));
 439                                                 goto freeshp;
 440                                         }
 441                                         if (nr != (ssize_t)shp[i].sh_size) {
 442                                                 errno = EIO;
 443                                                 WARN(("read symbols"));
 444                                                 goto freeshp;
 445                                         }
 446                                 }
 447                                 shp[i].sh_offset = maxp - elfp;
 448                                 maxp += roundup(shp[i].sh_size, ELFROUND);
 449                                 first = 0;
 450                                 break;
 451                         case SHT_NOTE:
 452                                 if ((flags & LOAD_NOTE) == 0)
 453                                         break;
 454                                 if (shp[i].sh_size < sizeof(note)) {
 455                                         shp[i].sh_offset = 0;
 456                                         break;
 457                                 }
 458                                 if (lseek(fd, shp[i].sh_offset, SEEK_SET)
 459                                     == -1) {
 460                                         WARN(("lseek note"));
 461                                         goto freeshp;
 462                                 }
 463                                 nr = read(fd, &note, sizeof(note));
 464                                 if (nr == -1) {
 465                                         WARN(("read note"));
 466                                         goto freeshp;
 467                                 }
 468                                 if (note.nh.n_namesz ==
 469                                     ELF_NOTE_NETBSD_NAMESZ &&
 470                                     note.nh.n_descsz ==
 471                                     ELF_NOTE_NETBSD_DESCSZ &&
 472                                     note.nh.n_type ==
 473                                     ELF_NOTE_TYPE_NETBSD_TAG &&
 474                                     memcmp(note.name, ELF_NOTE_NETBSD_NAME,
 475                                     sizeof(note.name)) == 0) {
 476                                         memcpy(&netbsd_version, &note.desc,
 477                                             sizeof(netbsd_version));
 478                                 }
 479                                 shp[i].sh_offset = 0;
 480                                 break;
 481                         }
 482                         /* Since we don't load .shstrtab, zero the name. */
 483                         shp[i].sh_name = 0;
 484                 }
 485                 if (flags & LOAD_SYM) {
 486 #ifndef _STANDALONE
 487                         /* Externalize the section headers. */
 488                         for (i = 0; i < elf->e_shnum; i++)
 489                                 externalize_shdr(elf->e_ident[EI_DATA],
 490                                     &shp[i]);
 491 #endif /* ! _STANDALONE */
 492                         BCOPY(shp, shpp, sz);
 493
 494                         if (first == 0)
 495                                 PROGRESS(("]"));
 496                 }
 497                 DEALLOC(shp, sz);
 498         }
 499
 500         /*
 501          * Frob the copied ELF header to give information relative
 502          * to elfp.
 503          */
 504         if (flags & LOAD_HDR) {
 505                 elf->e_phoff = 0;
 506                 elf->e_shoff = sizeof(Elf_Ehdr);
 507                 elf->e_phentsize = 0;
 508                 elf->e_phnum = 0;
 509                 elf->e_shstrndx = SHN_UNDEF;
 510                 externalize_ehdr(elf->e_ident[EI_DATA], elf);
 511                 BCOPY(elf, elfp, sizeof(*elf));
 512                 internalize_ehdr(elf->e_ident[EI_DATA], elf);
 513         }
 514
 515         marks[MARK_START] = LOADADDR(minp);
 516         marks[MARK_ENTRY] = LOADADDR(elf->e_entry);
 517         /*
 518          * Since there can be more than one symbol section in the code
 519          * and we need to find strtab too in order to do anything
 520          * useful with the symbols, we just pass the whole elf
 521          * header back and we let the kernel debugger find the
 522          * location and number of symbols by itself.
 523          */
 524         marks[MARK_NSYM] = 1;   /* XXX: Kernel needs >= 0 */
 525         marks[MARK_SYM] = LOADADDR(elfp);
 526         marks[MARK_END] = LOADADDR(maxp);
 527         return 0;
 528 freephdr:
 529         DEALLOC(phdr, sz);
 530         return 1;
 531 freeshp:
 532         DEALLOC(shp, sz);
 533         return 1;
 534 }
 535
 536 #ifdef TEST
 537 #include <stdlib.h>
 538 #include <fcntl.h>
 539 #include <err.h>
 540 #include <stdio.h>
 541 u_int32_t netbsd_version;
 542 int
 543 main(int argc, char *argv[])
 544 {
 545         int fd;
 546         u_long marks[MARK_MAX];
 547         Elf_Ehdr elf;
 548         if (argc != 2) {
 549                 (void)fprintf(stderr, "Usage: %s <file>\n", getprogname());
 550                 return 1;
 551         }
 552         if ((fd = open(argv[1], O_RDONLY)) == -1)
 553                 err(1, "Can't open `%s'", argv[1]);
 554         if (read(fd, &elf, sizeof(elf)) != sizeof(elf))
 555                 err(1, "Can't read `%s'", argv[1]);
 556         memset(marks, 0, sizeof(marks));
 557         marks[MARK_START] = (u_long)malloc(2LL * 1024 * 2024 * 1024);
 558         ELFNAMEEND(loadfile)(fd, &elf, marks, LOAD_ALL);
 559         printf("%d\n", netbsd_version);
 560         return 0;
 561 }
 562 #endif
 563
 564 #endif /* (ELFSIZE == 32 && BOOT_ELF32) || (ELFSIZE == 64 && BOOT_ELF64) */