usr.sbin/kldxref/ef.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-4-Clause
   3  *
   4  * Copyright (c) 2000, Boris Popov
   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
  40 #include <err.h>
  41 #include <errno.h>
  42 #include <fcntl.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47 #include <machine/elf.h>
  48 #define FREEBSD_ELF
  49
  50 #include "ef.h"
  51
  52 #define MAXSEGS 3
  53 struct ef_file {
  54         char            *ef_name;
  55         struct elf_file *ef_efile;
  56         Elf_Phdr        *ef_ph;
  57         int             ef_fd;
  58         int             ef_type;
  59         Elf_Ehdr        ef_hdr;
  60         void            *ef_fpage;              /* First block of the file */
  61         int             ef_fplen;               /* length of first block */
  62         Elf_Dyn         *ef_dyn;                /* Symbol table etc. */
  63         Elf_Hashelt     ef_nbuckets;
  64         Elf_Hashelt     ef_nchains;
  65         Elf_Hashelt     *ef_buckets;
  66         Elf_Hashelt     *ef_chains;
  67         Elf_Hashelt     *ef_hashtab;
  68         Elf_Off         ef_stroff;
  69         caddr_t         ef_strtab;
  70         int             ef_strsz;
  71         Elf_Off         ef_symoff;
  72         Elf_Sym         *ef_symtab;
  73         int             ef_nsegs;
  74         Elf_Phdr        *ef_segs[MAXSEGS];
  75         int             ef_verbose;
  76         Elf_Rel         *ef_rel;                /* relocation table */
  77         int             ef_relsz;               /* number of entries */
  78         Elf_Rela        *ef_rela;               /* relocation table */
  79         int             ef_relasz;              /* number of entries */
  80 };
  81
  82 static void     ef_print_phdr(Elf_Phdr *);
  83 static Elf_Off  ef_get_offset(elf_file_t, Elf_Off);
  84 static int      ef_parse_dynamic(elf_file_t);
  85
  86 static int      ef_get_type(elf_file_t ef);
  87 static int      ef_close(elf_file_t ef);
  88 static int      ef_read(elf_file_t ef, Elf_Off offset, size_t len, void *dest);
  89 static int      ef_read_entry(elf_file_t ef, Elf_Off offset, size_t len,
  90                     void **ptr);
  91
  92 static int      ef_seg_read(elf_file_t ef, Elf_Off offset, size_t len,
  93                     void *dest);
  94 static int      ef_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len,
  95                     void *dest);
  96 static int      ef_seg_read_string(elf_file_t ef, Elf_Off offset, size_t len,
  97                     char *dest);
  98 static int      ef_seg_read_entry(elf_file_t ef, Elf_Off offset, size_t len,
  99                     void **ptr);
 100 static int      ef_seg_read_entry_rel(elf_file_t ef, Elf_Off offset, size_t len,
 101                     void **ptr);
 102
 103 static Elf_Addr ef_symaddr(elf_file_t ef, Elf_Size symidx);
 104 static int      ef_lookup_set(elf_file_t ef, const char *name, long *startp,
 105                     long *stopp, long *countp);
 106 static int      ef_lookup_symbol(elf_file_t ef, const char *name,
 107                     Elf_Sym **sym);
 108
 109 static struct elf_file_ops ef_file_ops = {
 110         .get_type               = ef_get_type,
 111         .close                  = ef_close,
 112         .read                   = ef_read,
 113         .read_entry             = ef_read_entry,
 114         .seg_read               = ef_seg_read,
 115         .seg_read_rel           = ef_seg_read_rel,
 116         .seg_read_string        = ef_seg_read_string,
 117         .seg_read_entry         = ef_seg_read_entry,
 118         .seg_read_entry_rel     = ef_seg_read_entry_rel,
 119         .symaddr                = ef_symaddr,
 120         .lookup_set             = ef_lookup_set,
 121         .lookup_symbol          = ef_lookup_symbol
 122 };
 123
 124 static void
 125 ef_print_phdr(Elf_Phdr *phdr)
 126 {
 127
 128         if ((phdr->p_flags & PF_W) == 0) {
 129                 printf("text=0x%jx ", (uintmax_t)phdr->p_filesz);
 130         } else {
 131                 printf("data=0x%jx", (uintmax_t)phdr->p_filesz);
 132                 if (phdr->p_filesz < phdr->p_memsz)
 133                         printf("+0x%jx",
 134                             (uintmax_t)(phdr->p_memsz - phdr->p_filesz));
 135                 printf(" ");
 136         }
 137 }
 138
 139 static Elf_Off
 140 ef_get_offset(elf_file_t ef, Elf_Off off)
 141 {
 142         Elf_Phdr *ph;
 143         int i;
 144
 145         for (i = 0; i < ef->ef_nsegs; i++) {
 146                 ph = ef->ef_segs[i];
 147                 if (off >= ph->p_vaddr && off < ph->p_vaddr + ph->p_memsz) {
 148                         return (ph->p_offset + (off - ph->p_vaddr));
 149                 }
 150         }
 151         return (0);
 152 }
 153
 154 static int
 155 ef_get_type(elf_file_t ef)
 156 {
 157
 158         return (ef->ef_type);
 159 }
 160
 161 /*
 162  * next three functions copied from link_elf.c
 163  */
 164 static unsigned long
 165 elf_hash(const char *name)
 166 {
 167         unsigned long h, g;
 168         const unsigned char *p;
 169
 170         h = 0;
 171         p = (const unsigned char *)name;
 172         while (*p != '\0') {
 173                 h = (h << 4) + *p++;
 174                 if ((g = h & 0xf0000000) != 0)
 175                         h ^= g >> 24;
 176                 h &= ~g;
 177         }
 178         return (h);
 179 }
 180
 181 static int
 182 ef_lookup_symbol(elf_file_t ef, const char *name, Elf_Sym **sym)
 183 {
 184         unsigned long hash, symnum;
 185         Elf_Sym *symp;
 186         char *strp;
 187
 188         /* First, search hashed global symbols */
 189         hash = elf_hash(name);
 190         symnum = ef->ef_buckets[hash % ef->ef_nbuckets];
 191
 192         while (symnum != STN_UNDEF) {
 193                 if (symnum >= ef->ef_nchains) {
 194                         warnx("ef_lookup_symbol: file %s have corrupted symbol table\n",
 195                             ef->ef_name);
 196                         return (ENOENT);
 197                 }
 198
 199                 symp = ef->ef_symtab + symnum;
 200                 if (symp->st_name == 0) {
 201                         warnx("ef_lookup_symbol: file %s have corrupted symbol table\n",
 202                             ef->ef_name);
 203                         return (ENOENT);
 204                 }
 205
 206                 strp = ef->ef_strtab + symp->st_name;
 207
 208                 if (strcmp(name, strp) == 0) {
 209                         if (symp->st_shndx != SHN_UNDEF ||
 210                             (symp->st_value != 0 &&
 211                                 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
 212                                 *sym = symp;
 213                                 return (0);
 214                         } else
 215                                 return (ENOENT);
 216                 }
 217
 218                 symnum = ef->ef_chains[symnum];
 219         }
 220
 221         return (ENOENT);
 222 }
 223
 224 static int
 225 ef_lookup_set(elf_file_t ef, const char *name, long *startp, long *stopp,
 226     long *countp)
 227 {
 228         Elf_Sym *sym;
 229         char *setsym;
 230         int error, len;
 231
 232         len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */
 233         setsym = malloc(len);
 234         if (setsym == NULL)
 235                 return (errno);
 236
 237         /* get address of first entry */
 238         snprintf(setsym, len, "%s%s", "__start_set_", name);
 239         error = ef_lookup_symbol(ef, setsym, &sym);
 240         if (error != 0)
 241                 goto out;
 242         *startp = sym->st_value;
 243
 244         /* get address of last entry */
 245         snprintf(setsym, len, "%s%s", "__stop_set_", name);
 246         error = ef_lookup_symbol(ef, setsym, &sym);
 247         if (error != 0)
 248                 goto out;
 249         *stopp = sym->st_value;
 250
 251         /* and the number of entries */
 252         *countp = (*stopp - *startp) / sizeof(void *);
 253
 254 out:
 255         free(setsym);
 256         return (error);
 257 }
 258
 259 static Elf_Addr
 260 ef_symaddr(elf_file_t ef, Elf_Size symidx)
 261 {
 262         const Elf_Sym *sym;
 263
 264         if (symidx >= ef->ef_nchains)
 265                 return (0);
 266         sym = ef->ef_symtab + symidx;
 267
 268         if (ELF_ST_BIND(sym->st_info) == STB_LOCAL &&
 269             sym->st_shndx != SHN_UNDEF && sym->st_value != 0)
 270                 return (sym->st_value);
 271         return (0);
 272 }
 273
 274 static int
 275 ef_parse_dynamic(elf_file_t ef)
 276 {
 277         Elf_Dyn *dp;
 278         Elf_Hashelt hashhdr[2];
 279         int error;
 280         Elf_Off rel_off;
 281         Elf_Off rela_off;
 282         int rel_sz;
 283         int rela_sz;
 284         int rel_entry;
 285         int rela_entry;
 286
 287         rel_off = rela_off = 0;
 288         rel_sz = rela_sz = 0;
 289         rel_entry = rela_entry = 0;
 290         for (dp = ef->ef_dyn; dp->d_tag != DT_NULL; dp++) {
 291                 switch (dp->d_tag) {
 292                 case DT_HASH:
 293                         error = ef_read(ef, ef_get_offset(ef, dp->d_un.d_ptr),
 294                             sizeof(hashhdr),  hashhdr);
 295                         if (error != 0) {
 296                                 warnx("can't read hash header (%jx)",
 297                                   (uintmax_t)ef_get_offset(ef, dp->d_un.d_ptr));
 298                                 return (error);
 299                         }
 300                         ef->ef_nbuckets = hashhdr[0];
 301                         ef->ef_nchains = hashhdr[1];
 302                         error = ef_read_entry(ef, -1,
 303                             (hashhdr[0] + hashhdr[1]) * sizeof(Elf_Hashelt),
 304                             (void **)&ef->ef_hashtab);
 305                         if (error != 0) {
 306                                 warnx("can't read hash table");
 307                                 return (error);
 308                         }
 309                         ef->ef_buckets = ef->ef_hashtab;
 310                         ef->ef_chains = ef->ef_buckets + ef->ef_nbuckets;
 311                         break;
 312                 case DT_STRTAB:
 313                         ef->ef_stroff = dp->d_un.d_ptr;
 314                         break;
 315                 case DT_STRSZ:
 316                         ef->ef_strsz = dp->d_un.d_val;
 317                         break;
 318                 case DT_SYMTAB:
 319                         ef->ef_symoff = dp->d_un.d_ptr;
 320                         break;
 321                 case DT_SYMENT:
 322                         if (dp->d_un.d_val != sizeof(Elf_Sym))
 323                                 return (EFTYPE);
 324                         break;
 325                 case DT_REL:
 326                         if (rel_off != 0)
 327                                 warnx("second DT_REL entry ignored");
 328                         rel_off = dp->d_un.d_ptr;
 329                         break;
 330                 case DT_RELSZ:
 331                         if (rel_sz != 0)
 332                                 warnx("second DT_RELSZ entry ignored");
 333                         rel_sz = dp->d_un.d_val;
 334                         break;
 335                 case DT_RELENT:
 336                         if (rel_entry != 0)
 337                                 warnx("second DT_RELENT entry ignored");
 338                         rel_entry = dp->d_un.d_val;
 339                         break;
 340                 case DT_RELA:
 341                         if (rela_off != 0)
 342                                 warnx("second DT_RELA entry ignored");
 343                         rela_off = dp->d_un.d_ptr;
 344                         break;
 345                 case DT_RELASZ:
 346                         if (rela_sz != 0)
 347                                 warnx("second DT_RELASZ entry ignored");
 348                         rela_sz = dp->d_un.d_val;
 349                         break;
 350                 case DT_RELAENT:
 351                         if (rela_entry != 0)
 352                                 warnx("second DT_RELAENT entry ignored");
 353                         rela_entry = dp->d_un.d_val;
 354                         break;
 355                 }
 356         }
 357         if (ef->ef_symoff == 0) {
 358                 warnx("%s: no .dynsym section found\n", ef->ef_name);
 359                 return (EFTYPE);
 360         }
 361         if (ef->ef_stroff == 0) {
 362                 warnx("%s: no .dynstr section found\n", ef->ef_name);
 363                 return (EFTYPE);
 364         }
 365         if (ef_read_entry(ef, ef_get_offset(ef, ef->ef_symoff),
 366             ef->ef_nchains * sizeof(Elf_Sym),
 367                 (void **)&ef->ef_symtab) != 0) {
 368                 if (ef->ef_verbose)
 369                         warnx("%s: can't load .dynsym section (0x%jx)",
 370                             ef->ef_name, (uintmax_t)ef->ef_symoff);
 371                 return (EIO);
 372         }
 373         if (ef_read_entry(ef, ef_get_offset(ef, ef->ef_stroff), ef->ef_strsz,
 374                 (void **)&ef->ef_strtab) != 0) {
 375                 warnx("can't load .dynstr section");
 376                 return (EIO);
 377         }
 378         if (rel_off != 0) {
 379                 if (rel_entry == 0) {
 380                         warnx("%s: no DT_RELENT for DT_REL", ef->ef_name);
 381                         return (EFTYPE);
 382                 }
 383                 if (rel_entry != sizeof(Elf_Rel)) {
 384                         warnx("%s: inconsistent DT_RELENT value",
 385                             ef->ef_name);
 386                         return (EFTYPE);
 387                 }
 388                 if (rel_sz % rel_entry != 0) {
 389                         warnx("%s: inconsistent values for DT_RELSZ and "
 390                             "DT_RELENT", ef->ef_name);
 391                         return (EFTYPE);
 392                 }
 393                 if (ef_read_entry(ef, ef_get_offset(ef, rel_off), rel_sz,
 394                     (void **)&ef->ef_rel) != 0) {
 395                         warnx("%s: cannot load DT_REL section", ef->ef_name);
 396                         return (EIO);
 397                 }
 398                 ef->ef_relsz = rel_sz / rel_entry;
 399                 if (ef->ef_verbose)
 400                         warnx("%s: %d REL entries", ef->ef_name,
 401                             ef->ef_relsz);
 402         }
 403         if (rela_off != 0) {
 404                 if (rela_entry == 0) {
 405                         warnx("%s: no DT_RELAENT for DT_RELA", ef->ef_name);
 406                         return (EFTYPE);
 407                 }
 408                 if (rela_entry != sizeof(Elf_Rela)) {
 409                         warnx("%s: inconsistent DT_RELAENT value",
 410                             ef->ef_name);
 411                         return (EFTYPE);
 412                 }
 413                 if (rela_sz % rela_entry != 0) {
 414                         warnx("%s: inconsistent values for DT_RELASZ and "
 415                             "DT_RELAENT", ef->ef_name);
 416                         return (EFTYPE);
 417                 }
 418                 if (ef_read_entry(ef, ef_get_offset(ef, rela_off), rela_sz,
 419                     (void **)&ef->ef_rela) != 0) {
 420                         warnx("%s: cannot load DT_RELA section", ef->ef_name);
 421                         return (EIO);
 422                 }
 423                 ef->ef_relasz = rela_sz / rela_entry;
 424                 if (ef->ef_verbose)
 425                         warnx("%s: %d RELA entries", ef->ef_name,
 426                             ef->ef_relasz);
 427         }
 428         return (0);
 429 }
 430
 431 static int
 432 ef_read(elf_file_t ef, Elf_Off offset, size_t len, void *dest)
 433 {
 434         ssize_t r;
 435
 436         if (offset != (Elf_Off)-1) {
 437                 if (lseek(ef->ef_fd, offset, SEEK_SET) == -1)
 438                         return (EIO);
 439         }
 440
 441         r = read(ef->ef_fd, dest, len);
 442         if (r != -1 && (size_t)r == len)
 443                 return (0);
 444         else
 445                 return (EIO);
 446 }
 447
 448 static int
 449 ef_read_entry(elf_file_t ef, Elf_Off offset, size_t len, void **ptr)
 450 {
 451         int error;
 452
 453         *ptr = malloc(len);
 454         if (*ptr == NULL)
 455                 return (errno);
 456         error = ef_read(ef, offset, len, *ptr);
 457         if (error != 0)
 458                 free(*ptr);
 459         return (error);
 460 }
 461
 462 static int
 463 ef_seg_read(elf_file_t ef, Elf_Off offset, size_t len, void *dest)
 464 {
 465         Elf_Off ofs;
 466
 467         ofs = ef_get_offset(ef, offset);
 468         if (ofs == 0) {
 469                 if (ef->ef_verbose)
 470                         warnx("ef_seg_read(%s): zero offset (%jx:%ju)",
 471                             ef->ef_name, (uintmax_t)offset, (uintmax_t)ofs);
 472                 return (EFAULT);
 473         }
 474         return (ef_read(ef, ofs, len, dest));
 475 }
 476
 477 static int
 478 ef_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len, void *dest)
 479 {
 480         Elf_Off ofs;
 481         const Elf_Rela *a;
 482         const Elf_Rel *r;
 483         int error;
 484
 485         ofs = ef_get_offset(ef, offset);
 486         if (ofs == 0) {
 487                 if (ef->ef_verbose)
 488                         warnx("ef_seg_read_rel(%s): zero offset (%jx:%ju)",
 489                             ef->ef_name, (uintmax_t)offset, (uintmax_t)ofs);
 490                 return (EFAULT);
 491         }
 492         if ((error = ef_read(ef, ofs, len, dest)) != 0)
 493                 return (error);
 494
 495         for (r = ef->ef_rel; r < &ef->ef_rel[ef->ef_relsz]; r++) {
 496                 error = ef_reloc(ef->ef_efile, r, EF_RELOC_REL, 0, offset, len,
 497                     dest);
 498                 if (error != 0)
 499                         return (error);
 500         }
 501         for (a = ef->ef_rela; a < &ef->ef_rela[ef->ef_relasz]; a++) {
 502                 error = ef_reloc(ef->ef_efile, a, EF_RELOC_RELA, 0, offset, len,
 503                     dest);
 504                 if (error != 0)
 505                         return (error);
 506         }
 507         return (0);
 508 }
 509
 510 static int
 511 ef_seg_read_string(elf_file_t ef, Elf_Off offset, size_t len, char *dest)
 512 {
 513         Elf_Off ofs;
 514         ssize_t r;
 515
 516         ofs = ef_get_offset(ef, offset);
 517         if (ofs == 0 || ofs == (Elf_Off)-1) {
 518                 if (ef->ef_verbose)
 519                         warnx("ef_seg_read_string(%s): bad offset (%jx:%ju)",
 520                             ef->ef_name, (uintmax_t)offset, (uintmax_t)ofs);
 521                 return (EFAULT);
 522         }
 523
 524         r = pread(ef->ef_fd, dest, len, ofs);
 525         if (r < 0)
 526                 return (errno);
 527         if (strnlen(dest, len) == len)
 528                 return (EFAULT);
 529
 530         return (0);
 531 }
 532
 533 static int
 534 ef_seg_read_entry(elf_file_t ef, Elf_Off offset, size_t len, void **ptr)
 535 {
 536         int error;
 537
 538         *ptr = malloc(len);
 539         if (*ptr == NULL)
 540                 return (errno);
 541         error = ef_seg_read(ef, offset, len, *ptr);
 542         if (error != 0)
 543                 free(*ptr);
 544         return (error);
 545 }
 546
 547 static int
 548 ef_seg_read_entry_rel(elf_file_t ef, Elf_Off offset, size_t len, void **ptr)
 549 {
 550         int error;
 551
 552         *ptr = malloc(len);
 553         if (*ptr == NULL)
 554                 return (errno);
 555         error = ef_seg_read_rel(ef, offset, len, *ptr);
 556         if (error != 0)
 557                 free(*ptr);
 558         return (error);
 559 }
 560
 561 int
 562 ef_open(const char *filename, struct elf_file *efile, int verbose)
 563 {
 564         elf_file_t ef;
 565         Elf_Ehdr *hdr;
 566         int fd;
 567         int error;
 568         int phlen, res;
 569         int nsegs;
 570         Elf_Phdr *phdr, *phdyn, *phlimit;
 571
 572         if (filename == NULL)
 573                 return (EINVAL);
 574         if ((fd = open(filename, O_RDONLY)) == -1)
 575                 return (errno);
 576
 577         ef = malloc(sizeof(*ef));
 578         if (ef == NULL) {
 579                 close(fd);
 580                 return (errno);
 581         }
 582
 583         efile->ef_ef = ef;
 584         efile->ef_ops = &ef_file_ops;
 585
 586         bzero(ef, sizeof(*ef));
 587         ef->ef_verbose = verbose;
 588         ef->ef_fd = fd;
 589         ef->ef_name = strdup(filename);
 590         ef->ef_efile = efile;
 591         hdr = (Elf_Ehdr *)&ef->ef_hdr;
 592         do {
 593                 res = read(fd, hdr, sizeof(*hdr));
 594                 error = EFTYPE;
 595                 if (res != sizeof(*hdr))
 596                         break;
 597                 if (!IS_ELF(*hdr))
 598                         break;
 599                 if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
 600                     hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
 601                     hdr->e_ident[EI_VERSION] != EV_CURRENT ||
 602                     hdr->e_version != EV_CURRENT ||
 603                     hdr->e_machine != ELF_TARG_MACH ||
 604                     hdr->e_phentsize != sizeof(Elf_Phdr))
 605                         break;
 606                 phlen = hdr->e_phnum * sizeof(Elf_Phdr);
 607                 if (ef_read_entry(ef, hdr->e_phoff, phlen,
 608                     (void **)&ef->ef_ph) != 0)
 609                         break;
 610                 phdr = ef->ef_ph;
 611                 phlimit = phdr + hdr->e_phnum;
 612                 nsegs = 0;
 613                 phdyn = NULL;
 614                 while (phdr < phlimit) {
 615                         if (verbose > 1)
 616                                 ef_print_phdr(phdr);
 617                         switch (phdr->p_type) {
 618                         case PT_LOAD:
 619                                 if (nsegs < MAXSEGS)
 620                                         ef->ef_segs[nsegs] = phdr;
 621                                 nsegs++;
 622                                 break;
 623                         case PT_PHDR:
 624                                 break;
 625                         case PT_DYNAMIC:
 626                                 phdyn = phdr;
 627                                 break;
 628                         }
 629                         phdr++;
 630                 }
 631                 if (verbose > 1)
 632                         printf("\n");
 633                 if (phdyn == NULL) {
 634                         warnx("Skipping %s: not dynamically-linked",
 635                             filename);
 636                         break;
 637                 } else if (nsegs > MAXSEGS) {
 638                         warnx("%s: too many segments", filename);
 639                         break;
 640                 }
 641                 ef->ef_nsegs = nsegs;
 642                 if (ef_read_entry(ef, phdyn->p_offset,
 643                         phdyn->p_filesz, (void **)&ef->ef_dyn) != 0) {
 644                         printf("ef_read_entry failed\n");
 645                         break;
 646                 }
 647                 error = ef_parse_dynamic(ef);
 648                 if (error != 0)
 649                         break;
 650                 if (hdr->e_type == ET_DYN) {
 651                         ef->ef_type = EFT_KLD;
 652                         error = 0;
 653                 } else if (hdr->e_type == ET_EXEC) {
 654                         ef->ef_type = EFT_KERNEL;
 655                         error = 0;
 656                 } else
 657                         break;
 658         } while(0);
 659         if (error != 0)
 660                 ef_close(ef);
 661         return (error);
 662 }
 663
 664 static int
 665 ef_close(elf_file_t ef)
 666 {
 667
 668         close(ef->ef_fd);
 669         if (ef->ef_name)
 670                 free(ef->ef_name);
 671         ef->ef_efile->ef_ops = NULL;
 672         ef->ef_efile->ef_ef = NULL;
 673         free(ef);
 674         return (0);
 675 }