sys/boot/common/load_elf_obj.c

   1 /*-
   2  * Copyright (c) 2004 Ian Dowse <iedowse@freebsd.org>
   3  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
   4  * Copyright (c) 1998 Peter Wemm <peter@freebsd.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/boot/common/load_elf_obj.c,v 1.2 2005/12/18 04:52:35 marcel Exp $
  29  */
  30
  31 #include <sys/param.h>
  32 #include <sys/exec.h>
  33 #include <sys/linker.h>
  34 #include <sys/module.h>
  35 #include <inttypes.h>
  36 #include <string.h>
  37 #include <machine/elf.h>
  38 #include <stand.h>
  39 #define FREEBSD_ELF
  40 #include <link.h>
  41
  42 #include "bootstrap.h"
  43
  44 #define COPYOUT(s,d,l)  archsw.arch_copyout((vm_offset_t)(s), d, l)
  45
  46 #if defined(__i386__) && __ELF_WORD_SIZE == 64
  47 #undef ELF_TARG_CLASS
  48 #undef ELF_TARG_MACH
  49 #define ELF_TARG_CLASS  ELFCLASS64
  50 #define ELF_TARG_MACH   EM_X86_64
  51 #endif
  52
  53 typedef struct elf_file {
  54         Elf_Ehdr        hdr;
  55         Elf_Shdr        *e_shdr;
  56
  57         int             symtabindex;    /* Index of symbol table */
  58         int             shstrindex;     /* Index of section name string table */
  59
  60         int             fd;
  61         vm_offset_t     off;
  62 } *elf_file_t;
  63
  64 static int __elfN(obj_loadimage)(struct preloaded_file *mp, elf_file_t ef,
  65     u_int64_t loadaddr);
  66 static int __elfN(obj_lookup_set)(struct preloaded_file *mp, elf_file_t ef,
  67     const char *name, Elf_Addr *startp, Elf_Addr *stopp, int *countp);
  68 static int __elfN(obj_reloc_ptr)(struct preloaded_file *mp, elf_file_t ef,
  69     Elf_Addr p, void *val, size_t len);
  70 static int __elfN(obj_parse_modmetadata)(struct preloaded_file *mp,
  71     elf_file_t ef);
  72 static Elf_Addr __elfN(obj_symaddr)(struct elf_file *ef, Elf_Size symidx);
  73
  74 const char      *__elfN(obj_kerneltype) = "elf kernel";
  75 const char      *__elfN(obj_moduletype) = "elf obj module";
  76
  77 /*
  78  * Attempt to load the file (file) as an ELF module.  It will be stored at
  79  * (dest), and a pointer to a module structure describing the loaded object
  80  * will be saved in (result).
  81  */
  82 int
  83 __elfN(obj_loadfile)(char *filename, u_int64_t dest,
  84     struct preloaded_file **result)
  85 {
  86         struct preloaded_file *fp, *kfp;
  87         struct elf_file ef;
  88         Elf_Ehdr *hdr;
  89         int err;
  90         ssize_t bytes_read;
  91
  92         fp = NULL;
  93         bzero(&ef, sizeof(struct elf_file));
  94
  95         /*
  96          * Open the image, read and validate the ELF header
  97          */
  98         if (filename == NULL)   /* can't handle nameless */
  99                 return(EFTYPE);
 100         if ((ef.fd = rel_open(filename, O_RDONLY)) == -1)
 101                 return(errno);
 102
 103         hdr = &ef.hdr;
 104         bytes_read = read(ef.fd, hdr, sizeof(*hdr));
 105         if (bytes_read != sizeof(*hdr)) {
 106                 err = EFTYPE;   /* could be EIO, but may be small file */
 107                 goto oerr;
 108         }
 109
 110         /* Is it ELF? */
 111         if (!IS_ELF(*hdr)) {
 112                 err = EFTYPE;
 113                 goto oerr;
 114         }
 115         if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || /* Layout ? */
 116             hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
 117             hdr->e_ident[EI_VERSION] != EV_CURRENT ||   /* Version ? */
 118             hdr->e_version != EV_CURRENT ||
 119             hdr->e_machine != ELF_TARG_MACH ||          /* Machine ? */
 120             hdr->e_type != ET_REL) {
 121                 err = EFTYPE;
 122                 goto oerr;
 123         }
 124
 125         if (hdr->e_shnum * hdr->e_shentsize == 0 || hdr->e_shoff == 0 ||
 126             hdr->e_shentsize != sizeof(Elf_Shdr)) {
 127                 err = EFTYPE;
 128                 goto oerr;
 129         }
 130
 131         kfp = file_findfile(NULL, NULL);
 132         if (kfp == NULL) {
 133                 printf("elf" __XSTRING(__ELF_WORD_SIZE)
 134                     "_obj_loadfile: can't load module before kernel\n");
 135                 err = EPERM;
 136                 goto oerr;
 137         }
 138         if (strcmp(__elfN(obj_kerneltype), kfp->f_type)) {
 139                 printf("elf" __XSTRING(__ELF_WORD_SIZE)
 140                     "_obj_loadfile: can't load module with kernel type '%s'\n",
 141                     kfp->f_type);
 142                 err = EPERM;
 143                 goto oerr;
 144         }
 145
 146         /* Page-align the load address */
 147         dest = roundup(dest, PAGE_SIZE);
 148
 149         /*
 150          * Ok, we think we should handle this.
 151          */
 152         fp = file_alloc();
 153         if (fp == NULL) {
 154                 printf("elf" __XSTRING(__ELF_WORD_SIZE)
 155                     "_obj_loadfile: cannot allocate module info\n");
 156                 err = EPERM;
 157                 goto out;
 158         }
 159         fp->f_name = strdup(filename);
 160         fp->f_type = strdup(__elfN(obj_moduletype));
 161
 162         printf("%s ", filename);
 163
 164         fp->f_size = __elfN(obj_loadimage)(fp, &ef, dest);
 165         if (fp->f_size == 0 || fp->f_addr == 0)
 166                 goto ioerr;
 167
 168         /* save exec header as metadata */
 169         file_addmetadata(fp, MODINFOMD_ELFHDR, sizeof(*hdr), hdr);
 170
 171         /* Load OK, return module pointer */
 172         *result = (struct preloaded_file *)fp;
 173         err = 0;
 174         goto out;
 175
 176 ioerr:
 177         err = EIO;
 178 oerr:
 179         file_discard(fp);
 180 out:
 181         close(ef.fd);
 182         if (ef.e_shdr != NULL)
 183                 free(ef.e_shdr);
 184
 185         return(err);
 186 }
 187
 188 /*
 189  * With the file (fd) open on the image, and (ehdr) containing
 190  * the Elf header, load the image at (off)
 191  */
 192 static int
 193 __elfN(obj_loadimage)(struct preloaded_file *fp, elf_file_t ef, u_int64_t off)
 194 {
 195         Elf_Ehdr *hdr;
 196         Elf_Shdr *shdr;
 197         vm_offset_t firstaddr, lastaddr;
 198         int i, nsym, res, ret, shdrbytes, symstrindex;
 199
 200         ret = 0;
 201         firstaddr = lastaddr = (vm_offset_t)off;
 202         hdr = &ef->hdr;
 203         ef->off = (vm_offset_t)off;
 204
 205         /* Read in the section headers. */
 206         shdrbytes = hdr->e_shnum * hdr->e_shentsize;
 207         shdr = alloc_pread(ef->fd, (off_t)hdr->e_shoff, shdrbytes);
 208         if (shdr == NULL) {
 209                 printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 210                     "_obj_loadimage: read section headers failed\n");
 211                 goto out;
 212         }
 213         ef->e_shdr = shdr;
 214
 215         /*
 216          * Decide where to load everything, but don't read it yet.
 217          * We store the load address as a non-zero sh_addr value.
 218          * Start with the code/data and bss.
 219          */
 220         for (i = 0; i < hdr->e_shnum; i++)
 221                 shdr[i].sh_addr = 0;
 222         for (i = 0; i < hdr->e_shnum; i++) {
 223                 switch (shdr[i].sh_type) {
 224                 case SHT_PROGBITS:
 225                 case SHT_NOBITS:
 226                         lastaddr = roundup(lastaddr, shdr[i].sh_addralign);
 227                         shdr[i].sh_addr = (Elf_Addr)lastaddr;
 228                         lastaddr += shdr[i].sh_size;
 229                         break;
 230                 }
 231         }
 232
 233         /* Symbols. */
 234         nsym = 0;
 235         for (i = 0; i < hdr->e_shnum; i++) {
 236                 switch (shdr[i].sh_type) {
 237                 case SHT_SYMTAB:
 238                         nsym++;
 239                         ef->symtabindex = i;
 240                         shdr[i].sh_addr = (Elf_Addr)lastaddr;
 241                         lastaddr += shdr[i].sh_size;
 242                         break;
 243                 }
 244         }
 245         if (nsym != 1) {
 246                 printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 247                     "_obj_loadimage: file has no valid symbol table\n");
 248                 goto out;
 249         }
 250         lastaddr = roundup(lastaddr, shdr[ef->symtabindex].sh_addralign);
 251         shdr[ef->symtabindex].sh_addr = (Elf_Addr)lastaddr;
 252         lastaddr += shdr[ef->symtabindex].sh_size;
 253
 254         symstrindex = shdr[ef->symtabindex].sh_link;
 255         if (symstrindex < 0 || symstrindex >= hdr->e_shnum ||
 256             shdr[symstrindex].sh_type != SHT_STRTAB) {
 257                 printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 258                     "_obj_loadimage: file has invalid symbol strings\n");
 259                 goto out;
 260         }
 261         lastaddr = roundup(lastaddr, shdr[symstrindex].sh_addralign);
 262         shdr[symstrindex].sh_addr = (Elf_Addr)lastaddr;
 263         lastaddr += shdr[symstrindex].sh_size;
 264
 265         /* Section names. */
 266         if (hdr->e_shstrndx == 0 || hdr->e_shstrndx >= hdr->e_shnum ||
 267             shdr[hdr->e_shstrndx].sh_type != SHT_STRTAB) {
 268                 printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 269                     "_obj_loadimage: file has no section names\n");
 270                 goto out;
 271         }
 272         ef->shstrindex = hdr->e_shstrndx;
 273         lastaddr = roundup(lastaddr, shdr[ef->shstrindex].sh_addralign);
 274         shdr[ef->shstrindex].sh_addr = (Elf_Addr)lastaddr;
 275         lastaddr += shdr[ef->shstrindex].sh_size;
 276
 277         /* Relocation tables. */
 278         for (i = 0; i < hdr->e_shnum; i++) {
 279                 switch (shdr[i].sh_type) {
 280                 case SHT_REL:
 281                 case SHT_RELA:
 282                         lastaddr = roundup(lastaddr, shdr[i].sh_addralign);
 283                         shdr[i].sh_addr = (Elf_Addr)lastaddr;
 284                         lastaddr += shdr[i].sh_size;
 285                         break;
 286                 }
 287         }
 288
 289         /* Clear the whole area, including bss regions. */
 290         kern_bzero(firstaddr, lastaddr - firstaddr);
 291
 292         /* Now read it all in. */
 293         for (i = 0; i < hdr->e_shnum; i++) {
 294                 if (shdr[i].sh_addr == 0 || shdr[i].sh_type == SHT_NOBITS)
 295                         continue;
 296                 if (kern_pread(ef->fd, (vm_offset_t)shdr[i].sh_addr,
 297                     shdr[i].sh_size, (off_t)shdr[i].sh_offset) != 0) {
 298                         printf("\nelf" __XSTRING(__ELF_WORD_SIZE)
 299                             "_obj_loadimage: read failed\n");
 300                         goto out;
 301                 }
 302         }
 303
 304         file_addmetadata(fp, MODINFOMD_SHDR, shdrbytes, shdr);
 305
 306         res = __elfN(obj_parse_modmetadata)(fp, ef);
 307         if (res != 0)
 308                 goto out;
 309
 310         ret = lastaddr - firstaddr;
 311         fp->f_addr = firstaddr;
 312
 313         printf("size 0x%lx at 0x%lx", (u_long)ret, (u_long)firstaddr);
 314
 315 out:
 316         printf("\n");
 317         return ret;
 318 }
 319
 320 #if defined(__i386__) && __ELF_WORD_SIZE == 64
 321 struct mod_metadata64 {
 322         int             md_version;     /* structure version MDTV_* */
 323         int             md_type;        /* type of entry MDT_* */
 324         u_int64_t       md_data;        /* specific data */
 325         u_int64_t       md_cval;        /* common string label */
 326 };
 327 #endif
 328
 329 int
 330 __elfN(obj_parse_modmetadata)(struct preloaded_file *fp, elf_file_t ef)
 331 {
 332         struct mod_metadata md;
 333 #if defined(__i386__) && __ELF_WORD_SIZE == 64
 334         struct mod_metadata64 md64;
 335 #endif
 336         struct mod_depend *mdepend;
 337         struct mod_version mver;
 338         char *s;
 339         int error, modcnt, minfolen;
 340         Elf_Addr v, p, p_stop;
 341
 342         if (__elfN(obj_lookup_set)(fp, ef, "modmetadata_set", &p, &p_stop,
 343             &modcnt) != 0)
 344                 return ENOENT;
 345
 346         modcnt = 0;
 347         while (p < p_stop) {
 348                 COPYOUT(p, &v, sizeof(v));
 349                 error = __elfN(obj_reloc_ptr)(fp, ef, p, &v, sizeof(v));
 350                 if (error != 0)
 351                         return (error);
 352 #if defined(__i386__) && __ELF_WORD_SIZE == 64
 353                 COPYOUT(v, &md64, sizeof(md64));
 354                 error = __elfN(obj_reloc_ptr)(fp, ef, v, &md64, sizeof(md64));
 355                 if (error != 0)
 356                         return (error);
 357                 md.md_version = md64.md_version;
 358                 md.md_type = md64.md_type;
 359                 md.md_cval = (const char *)(uintptr_t)md64.md_cval;
 360                 md.md_data = (void *)(uintptr_t)md64.md_data;
 361 #else
 362                 COPYOUT(v, &md, sizeof(md));
 363                 error = __elfN(obj_reloc_ptr)(fp, ef, v, &md, sizeof(md));
 364                 if (error != 0)
 365                         return (error);
 366 #endif
 367                 p += sizeof(Elf_Addr);
 368                 switch(md.md_type) {
 369                 case MDT_DEPEND:
 370                         s = strdupout((vm_offset_t)md.md_cval);
 371                         minfolen = sizeof(*mdepend) + strlen(s) + 1;
 372                         mdepend = malloc(minfolen);
 373                         if (mdepend == NULL)
 374                                 return ENOMEM;
 375                         COPYOUT((vm_offset_t)md.md_data, mdepend,
 376                             sizeof(*mdepend));
 377                         strcpy((char*)(mdepend + 1), s);
 378                         free(s);
 379                         file_addmetadata(fp, MODINFOMD_DEPLIST, minfolen,
 380                             mdepend);
 381                         free(mdepend);
 382                         break;
 383                 case MDT_VERSION:
 384                         s = strdupout((vm_offset_t)md.md_cval);
 385                         COPYOUT((vm_offset_t)md.md_data, &mver, sizeof(mver));
 386                         file_addmodule(fp, s, mver.mv_version, NULL);
 387                         free(s);
 388                         modcnt++;
 389                         break;
 390                 case MDT_MODULE:
 391                         break;
 392                 default:
 393                         printf("unknown type %d\n", md.md_type);
 394                         break;
 395                 }
 396         }
 397         return 0;
 398 }
 399
 400 static int
 401 __elfN(obj_lookup_set)(struct preloaded_file *fp, elf_file_t ef,
 402     const char* name, Elf_Addr *startp, Elf_Addr *stopp, int *countp)
 403 {
 404         Elf_Ehdr *hdr;
 405         Elf_Shdr *shdr;
 406         char *p;
 407         vm_offset_t shstrtab;
 408         int i;
 409
 410         hdr = &ef->hdr;
 411         shdr = ef->e_shdr;
 412         shstrtab = shdr[ef->shstrindex].sh_addr;
 413
 414         for (i = 0; i < hdr->e_shnum; i++) {
 415                 if (shdr[i].sh_type != SHT_PROGBITS)
 416                         continue;
 417                 if (shdr[i].sh_name == 0)
 418                         continue;
 419                 p = strdupout(shstrtab + shdr[i].sh_name);
 420                 if (strncmp(p, "set_", 4) == 0 && strcmp(p + 4, name) == 0) {
 421                         *startp = shdr[i].sh_addr;
 422                         *stopp = shdr[i].sh_addr +  shdr[i].sh_size;
 423                         *countp = (*stopp - *startp) / sizeof(Elf_Addr);
 424                         free(p);
 425                         return (0);
 426                 }
 427                 free(p);
 428         }
 429
 430         return (ESRCH);
 431 }
 432
 433 /*
 434  * Apply any intra-module relocations to the value. p is the load address
 435  * of the value and val/len is the value to be modified. This does NOT modify
 436  * the image in-place, because this is done by kern_linker later on.
 437  */
 438 static int
 439 __elfN(obj_reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, Elf_Addr p,
 440     void *val, size_t len)
 441 {
 442         Elf_Ehdr *hdr;
 443         Elf_Shdr *shdr;
 444         Elf_Addr off = p;
 445         Elf_Addr base;
 446         Elf_Rela a, *abase;
 447         Elf_Rel r, *rbase;
 448         int error, i, j, nrel, nrela;
 449
 450         hdr = &ef->hdr;
 451         shdr = ef->e_shdr;
 452
 453         for (i = 0; i < hdr->e_shnum; i++) {
 454                 if (shdr[i].sh_type != SHT_RELA && shdr[i].sh_type != SHT_REL)
 455                         continue;
 456                 base = shdr[shdr[i].sh_info].sh_addr;
 457                 if (base == 0 || shdr[i].sh_addr == 0)
 458                         continue;
 459                 if (off < base || off + len > base +
 460                     shdr[shdr[i].sh_info].sh_size)
 461                         continue;
 462
 463                 switch (shdr[i].sh_type) {
 464                 case SHT_RELA:
 465                         abase = (Elf_Rela *)(intptr_t)shdr[i].sh_addr;
 466
 467                         nrela = shdr[i].sh_size / sizeof(Elf_Rela);
 468                         for (j = 0; j < nrela; j++) {
 469                                 COPYOUT(abase + j, &a, sizeof(a));
 470
 471                                 error = __elfN(reloc)(ef, __elfN(obj_symaddr),
 472                                     &a, ELF_RELOC_RELA, base, off, val, len);
 473                                 if (error != 0)
 474                                         return (error);
 475                         }
 476                         break;
 477                 case SHT_REL:
 478                         rbase = (Elf_Rel *)(intptr_t)shdr[i].sh_addr;
 479
 480                         nrel = shdr[i].sh_size / sizeof(Elf_Rel);
 481                         for (j = 0; j < nrel; j++) {
 482                                 COPYOUT(rbase + j, &r, sizeof(r));
 483
 484                                 error = __elfN(reloc)(ef, __elfN(obj_symaddr),
 485                                     &r, ELF_RELOC_REL, base, off, val, len);
 486                                 if (error != 0)
 487                                         return (error);
 488                         }
 489                         break;
 490                 }
 491         }
 492         return (0);
 493 }
 494
 495 /* Look up the address of a specified symbol. */
 496 static Elf_Addr
 497 __elfN(obj_symaddr)(struct elf_file *ef, Elf_Size symidx)
 498 {
 499         Elf_Sym sym;
 500         Elf_Addr base;
 501         int symcnt;
 502
 503         symcnt = ef->e_shdr[ef->symtabindex].sh_size / sizeof(Elf_Sym);
 504         if (symidx >= symcnt)
 505                 return (0);
 506         COPYOUT(ef->e_shdr[ef->symtabindex].sh_addr + symidx * sizeof(Elf_Sym),
 507             &sym, sizeof(sym));
 508         if (sym.st_shndx == SHN_UNDEF || sym.st_shndx >= ef->hdr.e_shnum)
 509                 return (0);
 510         base = ef->e_shdr[sym.st_shndx].sh_addr;
 511         if (base == 0)
 512                 return (0);
 513         return (base + sym.st_value);
 514 }