usr.sbin/kldxref/ef_obj.c

   1 /*
   2  * Copyright (c) 2000, Boris Popov
   3  * Copyright (c) 1998-2000 Doug Rabson
   4  * Copyright (c) 2004 Peter Wemm
   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  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *    This product includes software developed by Boris Popov.
  18  * 4. Neither the name of the author nor the names of any co-contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $FreeBSD$
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/linker.h>
  39 #include <string.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <unistd.h>
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #include <machine/elf.h>
  46 #define FREEBSD_ELF
  47
  48 #include <err.h>
  49
  50 #include "ef.h"
  51
  52 typedef struct {
  53         void            *addr;
  54         Elf_Off         size;
  55         int             flags;
  56         int             sec;    /* Original section */
  57         char            *name;
  58 } Elf_progent;
  59
  60 typedef struct {
  61         Elf_Rel         *rel;
  62         int             nrel;
  63         int             sec;
  64 } Elf_relent;
  65
  66 typedef struct {
  67         Elf_Rela        *rela;
  68         int             nrela;
  69         int             sec;
  70 } Elf_relaent;
  71
  72 struct ef_file {
  73         char            *ef_name;
  74         int             ef_fd;
  75         Elf_Ehdr        ef_hdr;
  76         struct elf_file *ef_efile;
  77
  78         caddr_t         address;
  79         Elf_Off         size;
  80         Elf_Shdr        *e_shdr;
  81
  82         Elf_progent     *progtab;
  83         int             nprogtab;
  84
  85         Elf_relaent     *relatab;
  86         int             nrela;
  87
  88         Elf_relent      *reltab;
  89         int             nrel;
  90
  91         Elf_Sym         *ddbsymtab;     /* The symbol table we are using */
  92         long            ddbsymcnt;      /* Number of symbols */
  93         caddr_t         ddbstrtab;      /* String table */
  94         long            ddbstrcnt;      /* number of bytes in string table */
  95
  96         caddr_t         shstrtab;       /* Section name string table */
  97         long            shstrcnt;       /* number of bytes in string table */
  98
  99         int             ef_verbose;
 100 };
 101
 102 static int ef_obj_get_type(elf_file_t ef);
 103 static int ef_obj_close(elf_file_t ef);
 104 static int ef_obj_read(elf_file_t ef, Elf_Off offset, size_t len, void* dest);
 105 static int ef_obj_read_entry(elf_file_t ef, Elf_Off offset, size_t len,
 106     void **ptr);
 107 static int ef_obj_seg_read(elf_file_t ef, Elf_Off offset, size_t len,
 108     void *dest);
 109 static int ef_obj_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len,
 110     void *dest);
 111 static int ef_obj_seg_read_entry(elf_file_t ef, Elf_Off offset, size_t len,
 112     void **ptr);
 113 static int ef_obj_seg_read_entry_rel(elf_file_t ef, Elf_Off offset, size_t len,
 114     void **ptr);
 115 static Elf_Addr ef_obj_symaddr(elf_file_t ef, Elf_Size symidx);
 116 static int ef_obj_lookup_set(elf_file_t ef, const char *name, long *startp,
 117     long *stopp, long *countp);
 118 static int ef_obj_lookup_symbol(elf_file_t ef, const char* name, Elf_Sym** sym);
 119
 120 static struct elf_file_ops ef_obj_file_ops = {
 121         ef_obj_get_type,
 122         ef_obj_close,
 123         ef_obj_read,
 124         ef_obj_read_entry,
 125         ef_obj_seg_read,
 126         ef_obj_seg_read_rel,
 127         ef_obj_seg_read_entry,
 128         ef_obj_seg_read_entry_rel,
 129         ef_obj_symaddr,
 130         ef_obj_lookup_set,
 131         ef_obj_lookup_symbol
 132 };
 133
 134 static int
 135 ef_obj_get_type(elf_file_t __unused ef)
 136 {
 137
 138         return (EFT_KLD);
 139 }
 140
 141 static int
 142 ef_obj_lookup_symbol(elf_file_t ef, const char* name, Elf_Sym** sym)
 143 {
 144         Elf_Sym *symp;
 145         const char *strp;
 146         int i;
 147
 148         for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
 149                 strp = ef->ddbstrtab + symp->st_name;
 150                 if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) {
 151                         *sym = symp;
 152                         return 0;
 153                 }
 154         }
 155         return ENOENT;
 156 }
 157
 158 static int
 159 ef_obj_lookup_set(elf_file_t ef, const char *name, long *startp, long *stopp,
 160     long *countp)
 161 {
 162         int i;
 163
 164         for (i = 0; i < ef->nprogtab; i++) {
 165                 if ((strncmp(ef->progtab[i].name, "set_", 4) == 0) &&
 166                     strcmp(ef->progtab[i].name + 4, name) == 0) {
 167                         *startp = (char *)ef->progtab[i].addr - ef->address;
 168                         *stopp = (char *)ef->progtab[i].addr +
 169                             ef->progtab[i].size - ef->address;
 170                         *countp = (*stopp - *startp) / sizeof(void *);
 171                         return (0);
 172                 }
 173         }
 174         return (ESRCH);
 175 }
 176
 177 static Elf_Addr
 178 ef_obj_symaddr(elf_file_t ef, Elf_Size symidx)
 179 {
 180         const Elf_Sym *sym;
 181
 182         if (symidx >= (size_t) ef->ddbsymcnt)
 183                 return (0);
 184         sym = ef->ddbsymtab + symidx;
 185
 186         if (sym->st_shndx != SHN_UNDEF)
 187                 return (sym->st_value - (Elf_Addr)ef->address);
 188         return (0);
 189 }
 190
 191 static int
 192 ef_obj_read(elf_file_t ef, Elf_Off offset, size_t len, void *dest)
 193 {
 194         ssize_t r;
 195
 196         if (offset != (Elf_Off)-1) {
 197                 if (lseek(ef->ef_fd, offset, SEEK_SET) == -1)
 198                         return EIO;
 199         }
 200
 201         r = read(ef->ef_fd, dest, len);
 202         if (r != -1 && (size_t)r == len)
 203                 return 0;
 204         else
 205                 return EIO;
 206 }
 207
 208 static int
 209 ef_obj_read_entry(elf_file_t ef, Elf_Off offset, size_t len, void **ptr)
 210 {
 211         int error;
 212
 213         *ptr = malloc(len);
 214         if (*ptr == NULL)
 215                 return ENOMEM;
 216         error = ef_obj_read(ef, offset, len, *ptr);
 217         if (error)
 218                 free(*ptr);
 219         return error;
 220 }
 221
 222 static int
 223 ef_obj_seg_read(elf_file_t ef, Elf_Off offset, size_t len, void *dest)
 224 {
 225
 226         if (offset + len > ef->size) {
 227                 if (ef->ef_verbose)
 228                         warnx("ef_seg_read_rel(%s): bad offset/len (%lx:%ld)",
 229                             ef->ef_name, (long)offset, (long)len);
 230                 return (EFAULT);
 231         }
 232         bcopy(ef->address + offset, dest, len);
 233         return (0);
 234 }
 235
 236 static int
 237 ef_obj_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len, void *dest)
 238 {
 239         char *memaddr;
 240         Elf_Rel *r;
 241         Elf_Rela *a;
 242         Elf_Off secbase, dataoff;
 243         int error, i, sec;
 244
 245         if (offset + len > ef->size) {
 246                 if (ef->ef_verbose)
 247                         warnx("ef_seg_read_rel(%s): bad offset/len (%lx:%ld)",
 248                             ef->ef_name, (long)offset, (long)len);
 249                 return (EFAULT);
 250         }
 251         bcopy(ef->address + offset, dest, len);
 252
 253         /* Find out which section contains the data. */
 254         memaddr = ef->address + offset;
 255         sec = -1;
 256         secbase = dataoff = 0;
 257         for (i = 0; i < ef->nprogtab; i++) {
 258                 if (ef->progtab[i].addr == NULL)
 259                         continue;
 260                 if (memaddr < (char *)ef->progtab[i].addr || memaddr + len >
 261                      (char *)ef->progtab[i].addr + ef->progtab[i].size)
 262                         continue;
 263                 sec = ef->progtab[i].sec;
 264                 /* We relocate to address 0. */
 265                 secbase = (char *)ef->progtab[i].addr - ef->address;
 266                 dataoff = memaddr - ef->address;
 267                 break;
 268         }
 269
 270         if (sec == -1)
 271                 return (EFAULT);
 272
 273         /* Now do the relocations. */
 274         for (i = 0; i < ef->nrel; i++) {
 275                 if (ef->reltab[i].sec != sec)
 276                         continue;
 277                 for (r = ef->reltab[i].rel;
 278                      r < &ef->reltab[i].rel[ef->reltab[i].nrel]; r++) {
 279                         error = ef_reloc(ef->ef_efile, r, EF_RELOC_REL, secbase,
 280                             dataoff, len, dest);
 281                         if (error != 0)
 282                                 return (error);
 283                 }
 284         }
 285         for (i = 0; i < ef->nrela; i++) {
 286                 if (ef->relatab[i].sec != sec)
 287                         continue;
 288                 for (a = ef->relatab[i].rela;
 289                      a < &ef->relatab[i].rela[ef->relatab[i].nrela]; a++) {
 290                         error = ef_reloc(ef->ef_efile, a, EF_RELOC_RELA,
 291                             secbase, dataoff, len, dest);
 292                         if (error != 0)
 293                                 return (error);
 294                 }
 295         }
 296         return (0);
 297 }
 298
 299 static int
 300 ef_obj_seg_read_entry(elf_file_t ef, Elf_Off offset, size_t len, void **ptr)
 301 {
 302         int error;
 303
 304         *ptr = malloc(len);
 305         if (*ptr == NULL)
 306                 return ENOMEM;
 307         error = ef_obj_seg_read(ef, offset, len, *ptr);
 308         if (error)
 309                 free(*ptr);
 310         return error;
 311 }
 312
 313 static int
 314 ef_obj_seg_read_entry_rel(elf_file_t ef, Elf_Off offset, size_t len,
 315     void **ptr)
 316 {
 317         int error;
 318
 319         *ptr = malloc(len);
 320         if (*ptr == NULL)
 321                 return ENOMEM;
 322         error = ef_obj_seg_read_rel(ef, offset, len, *ptr);
 323         if (error)
 324                 free(*ptr);
 325         return error;
 326 }
 327
 328 int
 329 ef_obj_open(const char *filename, struct elf_file *efile, int verbose)
 330 {
 331         elf_file_t ef;
 332         Elf_Ehdr *hdr;
 333         Elf_Shdr *shdr;
 334         Elf_Sym *es;
 335         char *mapbase;
 336         void *vtmp;
 337         size_t mapsize, alignmask, max_addralign;
 338         int error, fd, pb, ra, res, rl;
 339         int i, j, nbytes, nsym, shstrindex, symstrindex, symtabindex;
 340
 341         if (filename == NULL)
 342                 return EFTYPE;
 343         if ((fd = open(filename, O_RDONLY)) == -1)
 344                 return errno;
 345
 346         ef = calloc(1, sizeof(*ef));
 347         if (ef == NULL) {
 348                 close(fd);
 349                 return (ENOMEM);
 350         }
 351
 352         efile->ef_ef = ef;
 353         efile->ef_ops = &ef_obj_file_ops;
 354
 355         ef->ef_verbose = verbose;
 356         ef->ef_fd = fd;
 357         ef->ef_name = strdup(filename);
 358         ef->ef_efile = efile;
 359         hdr = (Elf_Ehdr *)&ef->ef_hdr;
 360
 361         res = read(fd, hdr, sizeof(*hdr));
 362         error = EFTYPE;
 363         if (res != sizeof(*hdr))
 364                 goto out;
 365         if (!IS_ELF(*hdr))
 366                 goto out;
 367         if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
 368             hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
 369             hdr->e_ident[EI_VERSION] != EV_CURRENT ||
 370             hdr->e_version != EV_CURRENT || hdr->e_machine != ELF_TARG_MACH ||
 371             hdr->e_type != ET_REL)
 372                 goto out;
 373
 374         nbytes = hdr->e_shnum * hdr->e_shentsize;
 375         if (nbytes == 0 || hdr->e_shoff == 0 ||
 376             hdr->e_shentsize != sizeof(Elf_Shdr))
 377                 goto out;
 378
 379         if (ef_obj_read_entry(ef, hdr->e_shoff, nbytes, &vtmp) != 0) {
 380                 printf("ef_read_entry failed\n");
 381                 goto out;
 382         }
 383         ef->e_shdr = shdr = vtmp;
 384
 385         /* Scan the section header for information and table sizing. */
 386         nsym = 0;
 387         symtabindex = -1;
 388         symstrindex = -1;
 389         for (i = 0; i < hdr->e_shnum; i++) {
 390                 switch (shdr[i].sh_type) {
 391                 case SHT_PROGBITS:
 392                 case SHT_NOBITS:
 393                         ef->nprogtab++;
 394                         break;
 395                 case SHT_SYMTAB:
 396                         nsym++;
 397                         symtabindex = i;
 398                         symstrindex = shdr[i].sh_link;
 399                         break;
 400                 case SHT_REL:
 401                         ef->nrel++;
 402                         break;
 403                 case SHT_RELA:
 404                         ef->nrela++;
 405                         break;
 406                 case SHT_STRTAB:
 407                         break;
 408                 }
 409         }
 410
 411         if (ef->nprogtab == 0) {
 412                 warnx("%s: file has no contents", filename);
 413                 goto out;
 414         }
 415         if (nsym != 1) {
 416                 warnx("%s: file has no valid symbol table", filename);
 417                 goto out;
 418         }
 419         if (symstrindex < 0 || symstrindex > hdr->e_shnum ||
 420             shdr[symstrindex].sh_type != SHT_STRTAB) {
 421                 warnx("%s: file has invalid symbol strings", filename);
 422                 goto out;
 423         }
 424
 425         /* Allocate space for tracking the load chunks */
 426         if (ef->nprogtab != 0)
 427                 ef->progtab = calloc(ef->nprogtab, sizeof(*ef->progtab));
 428         if (ef->nrel != 0)
 429                 ef->reltab = calloc(ef->nrel, sizeof(*ef->reltab));
 430         if (ef->nrela != 0)
 431                 ef->relatab = calloc(ef->nrela, sizeof(*ef->relatab));
 432         if ((ef->nprogtab != 0 && ef->progtab == NULL) ||
 433             (ef->nrel != 0 && ef->reltab == NULL) ||
 434             (ef->nrela != 0 && ef->relatab == NULL)) {
 435                 printf("malloc failed\n");
 436                 error = ENOMEM;
 437                 goto out;
 438         }
 439
 440         ef->ddbsymcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
 441         if (ef_obj_read_entry(ef, shdr[symtabindex].sh_offset,
 442             shdr[symtabindex].sh_size, (void**)&ef->ddbsymtab) != 0) {
 443                 printf("ef_read_entry failed\n");
 444                 goto out;
 445         }
 446
 447         ef->ddbstrcnt = shdr[symstrindex].sh_size;
 448         if (ef_obj_read_entry(ef, shdr[symstrindex].sh_offset,
 449             shdr[symstrindex].sh_size, (void**)&ef->ddbstrtab) != 0) {
 450                 printf("ef_read_entry failed\n");
 451                 goto out;
 452         }
 453
 454         /* Do we have a string table for the section names?  */
 455         shstrindex = -1;
 456         if (hdr->e_shstrndx != 0 &&
 457             shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) {
 458                 shstrindex = hdr->e_shstrndx;
 459                 ef->shstrcnt = shdr[shstrindex].sh_size;
 460                 if (ef_obj_read_entry(ef, shdr[shstrindex].sh_offset,
 461                     shdr[shstrindex].sh_size, (void**)&ef->shstrtab) != 0) {
 462                         printf("ef_read_entry failed\n");
 463                         goto out;
 464                 }
 465         }
 466
 467         /* Size up code/data(progbits) and bss(nobits). */
 468         alignmask = 0;
 469         max_addralign = 0;
 470         mapsize = 0;
 471         for (i = 0; i < hdr->e_shnum; i++) {
 472                 switch (shdr[i].sh_type) {
 473                 case SHT_PROGBITS:
 474                 case SHT_NOBITS:
 475                         alignmask = shdr[i].sh_addralign - 1;
 476                         if (shdr[i].sh_addralign > max_addralign)
 477                                 max_addralign = shdr[i].sh_addralign;
 478                         mapsize += alignmask;
 479                         mapsize &= ~alignmask;
 480                         mapsize += shdr[i].sh_size;
 481                         break;
 482                 }
 483         }
 484
 485         /* We know how much space we need for the text/data/bss/etc. */
 486         ef->size = mapsize;
 487         if (posix_memalign((void **)&ef->address, max_addralign, mapsize)) {
 488                 printf("posix_memalign failed\n");
 489                 goto out;
 490         }
 491         mapbase = ef->address;
 492
 493         /*
 494          * Now load code/data(progbits), zero bss(nobits), allocate
 495          * space for and load relocs
 496          */
 497         pb = 0;
 498         rl = 0;
 499         ra = 0;
 500         alignmask = 0;
 501         for (i = 0; i < hdr->e_shnum; i++) {
 502                 switch (shdr[i].sh_type) {
 503                 case SHT_PROGBITS:
 504                 case SHT_NOBITS:
 505                         alignmask = shdr[i].sh_addralign - 1;
 506                         mapbase += alignmask;
 507                         mapbase  = (char *)((uintptr_t)mapbase & ~alignmask);
 508                         ef->progtab[pb].addr = (void *)(uintptr_t)mapbase;
 509                         if (shdr[i].sh_type == SHT_PROGBITS) {
 510                                 ef->progtab[pb].name = "<<PROGBITS>>";
 511                                 if (ef_obj_read(ef, shdr[i].sh_offset,
 512                                     shdr[i].sh_size,
 513                                     ef->progtab[pb].addr) != 0) {
 514                                         printf("failed to read progbits\n");
 515                                         goto out;
 516                                 }
 517                         } else {
 518                                 ef->progtab[pb].name = "<<NOBITS>>";
 519                                 bzero(ef->progtab[pb].addr, shdr[i].sh_size);
 520                         }
 521                         ef->progtab[pb].size = shdr[i].sh_size;
 522                         ef->progtab[pb].sec = i;
 523                         if (ef->shstrtab && shdr[i].sh_name != 0)
 524                                 ef->progtab[pb].name =
 525                                     ef->shstrtab + shdr[i].sh_name;
 526
 527                         /* Update all symbol values with the offset. */
 528                         for (j = 0; j < ef->ddbsymcnt; j++) {
 529                                 es = &ef->ddbsymtab[j];
 530                                 if (es->st_shndx != i)
 531                                         continue;
 532                                 es->st_value += (Elf_Addr)ef->progtab[pb].addr;
 533                         }
 534                         mapbase += shdr[i].sh_size;
 535                         pb++;
 536                         break;
 537                 case SHT_REL:
 538                         ef->reltab[rl].nrel = shdr[i].sh_size / sizeof(Elf_Rel);
 539                         ef->reltab[rl].sec = shdr[i].sh_info;
 540                         if (ef_obj_read_entry(ef, shdr[i].sh_offset,
 541                             shdr[i].sh_size, (void**)&ef->reltab[rl].rel) !=
 542                             0) {
 543                                 printf("ef_read_entry failed\n");
 544                                 goto out;
 545                         }
 546                         rl++;
 547                         break;
 548                 case SHT_RELA:
 549                         ef->relatab[ra].nrela =
 550                             shdr[i].sh_size / sizeof(Elf_Rela);
 551                         ef->relatab[ra].sec = shdr[i].sh_info;
 552                         if (ef_obj_read_entry(ef, shdr[i].sh_offset,
 553                             shdr[i].sh_size, (void**)&ef->relatab[ra].rela) !=
 554                             0) {
 555                                 printf("ef_read_entry failed\n");
 556                                 goto out;
 557                         }
 558                         ra++;
 559                         break;
 560                 }
 561         }
 562         error = 0;
 563 out:
 564         if (error)
 565                 ef_obj_close(ef);
 566         return error;
 567 }
 568
 569 static int
 570 ef_obj_close(elf_file_t ef)
 571 {
 572         int i;
 573
 574         close(ef->ef_fd);
 575         if (ef->ef_name)
 576                 free(ef->ef_name);
 577         if (ef->e_shdr != NULL)
 578                 free(ef->e_shdr);
 579         if (ef->size != 0)
 580                 free(ef->address);
 581         if (ef->nprogtab != 0)
 582                 free(ef->progtab);
 583         if (ef->nrel != 0) {
 584                 for (i = 0; i < ef->nrel; i++)
 585                         if (ef->reltab[i].rel != NULL)
 586                                 free(ef->reltab[i].rel);
 587                 free(ef->reltab);
 588         }
 589         if (ef->nrela != 0) {
 590                 for (i = 0; i < ef->nrela; i++)
 591                         if (ef->relatab[i].rela != NULL)
 592                                 free(ef->relatab[i].rela);
 593                 free(ef->relatab);
 594         }
 595         if (ef->ddbsymtab != NULL)
 596                 free(ef->ddbsymtab);
 597         if (ef->ddbstrtab != NULL)
 598                 free(ef->ddbstrtab);
 599         if (ef->shstrtab != NULL)
 600                 free(ef->shstrtab);
 601         ef->ef_efile->ef_ops = NULL;
 602         ef->ef_efile->ef_ef = NULL;
 603         free(ef);
 604
 605         return 0;
 606 }