usr.sbin/kldxref/ef_obj.c

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