usr.sbin/kvm_mkdb/nlist_elf32.c

   1 /* $NetBSD: nlist_elf32.c,v 1.17 2003/09/19 06:24:04 itojun Exp $ */
   2
   3 /*
   4  * Copyright (c) 1996 Christopher G. Demetriou
   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 for the
  18  *          NetBSD Project.  See http://www.NetBSD.org/ for
  19  *          information about NetBSD.
  20  * 4. The name of the author may not be used to endorse or promote products
  21  *    derived from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * <<Id: LICENSE,v 1.2 2000/06/14 15:57:33 cgd Exp>>
  35  */
  36
  37 #include <sys/cdefs.h>
  38 #ifndef lint
  39 __RCSID("$NetBSD: nlist_elf32.c,v 1.17 2003/09/19 06:24:04 itojun Exp $");
  40 #endif /* not lint */
  41
  42 /* If not included by nlist_elf64.c, ELFSIZE won't be defined. */
  43 #ifndef ELFSIZE
  44 #define ELFSIZE         32
  45 #endif
  46
  47 #include <sys/param.h>
  48 #include <sys/mman.h>
  49 #include <sys/stat.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/ioctl.h>
  52 #include <sys/ksyms.h>
  53
  54 #include <a.out.h>
  55 #include <db.h>
  56 #include <err.h>
  57 #include <errno.h>
  58 #include <fcntl.h>
  59 #include <kvm.h>
  60 #include <limits.h>
  61 #include <paths.h>
  62 #include <stdio.h>
  63 #include <stdlib.h>
  64 #include <string.h>
  65 #include <unistd.h>
  66
  67 #include "extern.h"
  68
  69 #if defined(NLIST_ELF32) || defined(NLIST_ELF64)
  70 #include <sys/exec_elf.h>
  71 #endif
  72
  73 #if (defined(NLIST_ELF32) && (ELFSIZE == 32)) || \
  74     (defined(NLIST_ELF64) && (ELFSIZE == 64))
  75
  76 typedef struct nlist NLIST;
  77 #define _strx   n_un.n_strx
  78 #define _name   n_un.n_name
  79
  80 #define badfmt(str)                                                     \
  81         do {                                                            \
  82                 warnx("%s: %s: %s", kfile, str, strerror(EFTYPE));      \
  83                 punt();                                                 \
  84         } while (0)
  85
  86 #define check(off, size)        ((off < 0) || (off + size > mappedsize))
  87 #define BAD                     do { rv = -1; goto out; } while (0)
  88 #define BADUNMAP                do { rv = -1; goto unmap; } while (0)
  89
  90 static const char *kfile;
  91
  92 int
  93 ELFNAMEEND(create_knlist)(name, db)
  94         const char *name;
  95         DB *db;
  96 {
  97         struct stat st;
  98         struct nlist nbuf;
  99         DBT key, data;
 100         char *mappedfile, *symname, *nsymname, *fsymname, *tmpcp, *strtab;
 101         size_t mappedsize, symnamesize, fsymnamesize;
 102         Elf_Ehdr *ehdrp;
 103         Elf_Shdr *shdrp, *symshdrp, *symstrshdrp;
 104         Elf_Sym *symp;
 105         Elf_Off shdr_off;
 106         Elf_Word shdr_size;
 107 #if (ELFSIZE == 32)
 108         Elf32_Half nshdr;
 109 #elif (ELFSIZE == 64)
 110         Elf64_Half nshdr;
 111 #endif
 112         unsigned long i, nsyms;
 113         int fd, rv, malloced = 0, isksyms;
 114
 115         rv = -1;
 116 #ifdef __GNUC__
 117         /* fix compiler warnings */
 118         symshdrp = NULL;
 119         symstrshdrp = NULL;
 120 #endif
 121
 122         /*
 123          * Open and map the whole file.  If we can't open/stat it,
 124          * something bad is going on so we punt.
 125          */
 126         kfile = name;
 127         if ((fd = open(name, O_RDONLY, 0)) < 0) {
 128                 warn("%s", kfile);
 129                 punt();
 130         }
 131         if (fstat(fd, &st) < 0) {
 132                 warn("%s", kfile);
 133                 punt();
 134         }
 135         if (st.st_size > SIZE_T_MAX)
 136                 BAD;
 137
 138
 139         /*
 140          * Map the file in its entirety.
 141          */
 142         mappedfile = MAP_FAILED;
 143         mappedsize = st.st_size;
 144         isksyms = S_ISCHR(st.st_mode) &&
 145             strncmp(name, _PATH_KSYMS, sizeof(_PATH_KSYMS)) == 0;
 146
 147         if (mappedsize == 0) {
 148                 /* if it's a character device, stat returns size 0 */
 149                 if (!isksyms)
 150                         BAD;
 151         } else {
 152                 mappedfile = mmap(NULL, mappedsize, PROT_READ,
 153                     MAP_PRIVATE|MAP_FILE, fd, 0);
 154         }
 155
 156         /*
 157          * If mmap failed, try to read the file instead.
 158          */
 159         if (mappedfile == MAP_FAILED) {
 160                 int allocsiz, readsz;
 161
 162                 if (isksyms != 0) {
 163                         if (ioctl(fd, KIOCGSIZE, &allocsiz) < 0)
 164                                 BAD;
 165                         mappedsize = allocsiz;
 166                 } else
 167                         allocsiz = mappedsize;
 168
 169                 if ((mappedfile = malloc(mappedsize)) == NULL)
 170                         BAD;
 171                 malloced = 1;
 172                 if ((readsz = read(fd, mappedfile, mappedsize)) < 0)
 173                         BADUNMAP;
 174
 175                 if (readsz != mappedsize) /* Sanity */
 176                         BADUNMAP;
 177         }
 178         /*
 179          * Make sure we can access the executable's header
 180          * directly, and make sure the recognize the executable
 181          * as an ELF binary.
 182          */
 183         if (check(0, sizeof *ehdrp))
 184                 BADUNMAP;
 185         ehdrp = (Elf_Ehdr *)&mappedfile[0];
 186
 187         if (memcmp(ehdrp->e_ident, ELFMAG, SELFMAG) != 0 ||
 188             ehdrp->e_ident[EI_CLASS] != ELFCLASS)
 189                 BADUNMAP;
 190
 191         switch (ehdrp->e_machine) {
 192         ELFDEFNNAME(MACHDEP_ID_CASES)
 193
 194         default:
 195                 BADUNMAP;
 196         }
 197
 198         /*
 199          * We've recognized it as an ELF binary.  From here
 200          * on out, all errors are fatal.
 201          */
 202
 203         /*
 204          * Find the symbol list and string table.
 205          */
 206         nshdr = ehdrp->e_shnum;
 207         shdr_off = ehdrp->e_shoff;
 208         shdr_size = ehdrp->e_shentsize * nshdr;
 209
 210         if (check(shdr_off, shdr_size) ||
 211             (sizeof *shdrp != ehdrp->e_shentsize))
 212                 badfmt("bogus section header table");
 213         shdrp = (Elf_Shdr *)&mappedfile[shdr_off];
 214
 215         for (i = 0; i < nshdr; i++) {
 216                 if (shdrp[i].sh_type == SHT_SYMTAB) {
 217                         symshdrp = &shdrp[i];
 218                         symstrshdrp = &shdrp[shdrp[i].sh_link];
 219                 }
 220         }
 221
 222         if (symshdrp == NULL)
 223                 badfmt("no symbol section header found");
 224         if (symshdrp->sh_offset == 0)
 225                 badfmt("stripped");
 226         if (check(symshdrp->sh_offset, symshdrp->sh_size))
 227                 badfmt("bogus symbol section header");
 228         if (check(symstrshdrp->sh_offset, symstrshdrp->sh_size))
 229                 badfmt("bogus symbol string section header");
 230
 231         symp = (Elf_Sym *)&mappedfile[symshdrp->sh_offset];
 232         nsyms = symshdrp->sh_size / sizeof(*symp);
 233         strtab = &mappedfile[symstrshdrp->sh_offset];
 234
 235         /*
 236          * Set up the data item, pointing to a nlist structure.
 237          * which we fill in for each symbol.
 238          */
 239         data.data = (u_char *)&nbuf;
 240         data.size = sizeof(nbuf);
 241
 242         /*
 243          * Create a buffer (to be expanded later, if necessary)
 244          * to hold symbol names after we've added underscores
 245          * to them.
 246          */
 247         symnamesize = 1024;
 248         if ((symname = malloc(symnamesize)) == NULL) {
 249                 warn("malloc");
 250                 punt();
 251         }
 252
 253         /*
 254          * Read each symbol and enter it into the database.
 255          */
 256         for (i = 0; i < nsyms; i++) {
 257
 258                 /*
 259                  * No symbol name; ignore this symbol.
 260                  */
 261                 if (symp[i].st_name == 0)
 262                         continue;
 263
 264                 /*
 265                  * Find symbol name, copy it (with added underscore) to
 266                  * temporary buffer, and prepare the database key for
 267                  * insertion.
 268                  */
 269                 fsymname = &strtab[symp[i].st_name];
 270                 fsymnamesize = strlen(fsymname) + 1;
 271                 while (symnamesize < fsymnamesize + 1) {
 272                         if ((nsymname = realloc(symname, symnamesize * 2)) == NULL) {
 273                                 warn("malloc");
 274                                 punt();
 275                         }
 276                         symname = nsymname;
 277                         symnamesize *= 2;
 278                 }
 279                 strlcpy(symname, "_", symnamesize);
 280                 strlcat(symname, fsymname, symnamesize);
 281
 282                 key.data = symname;
 283                 key.size = strlen((char *)key.data);
 284
 285                 /*
 286                  * Convert the symbol information into an nlist structure,
 287                  * as best we can.
 288                  */
 289                 nbuf.n_value = symp[i].st_value;
 290                 switch (ELFDEFNNAME(ST_TYPE)(symp[i].st_info)) {
 291                 default:
 292                 case STT_NOTYPE:
 293                         nbuf.n_type = N_UNDF;
 294                         break;
 295                 case STT_OBJECT:
 296                         nbuf.n_type = N_DATA;
 297                         break;
 298                 case STT_FUNC:
 299                         nbuf.n_type = N_TEXT;
 300                         break;
 301                 case STT_FILE:
 302                         nbuf.n_type = N_FN;
 303                         break;
 304                 }
 305                 if (ELFDEFNNAME(ST_BIND)(symp[i].st_info) != STB_LOCAL)
 306                         nbuf.n_type |= N_EXT;
 307                 nbuf.n_desc = 0;                                /* XXX */
 308                 nbuf.n_other = 0;                               /* XXX */
 309
 310                 /*
 311                  * Enter the symbol into the database.
 312                  */
 313                 if (db->put(db, &key, &data, 0)) {
 314                         warn("record enter");
 315                         punt();
 316                 }
 317
 318                 /*
 319                  * If it's the kernel version string, we've gotta keep
 320                  * some extra data around.  Under a separate key,
 321                  * we enter the first line (i.e. up to the first newline,
 322                  * with the newline replaced by a NUL to terminate the
 323                  * entered string) of the version string.
 324                  */
 325                 if (strcmp((char *)key.data, VRS_SYM) == 0) {
 326                         key.data = (u_char *)VRS_KEY;
 327                         key.size = sizeof(VRS_KEY) - 1;
 328                         /* Find the version string, relative to its section */
 329                         if (isksyms) {
 330                                 /* reading from /dev/ksyms, use sysctl */
 331                                 size_t sz;
 332                                 int mib[2];
 333                                 char *kv;
 334
 335                                 mib[0] = CTL_KERN;
 336                                 mib[1] = KERN_VERSION;
 337                                 if (sysctl(mib, 2, NULL, &sz, NULL, 0) == -1) {
 338                                         warn("sysctl version size");
 339                                         punt();
 340                                 }
 341                                 if ((kv = malloc(sz)) == NULL) {
 342                                         warn("malloc version string");
 343                                         punt();
 344                                 }
 345                                 if (sysctl(mib, 2, kv, &sz, NULL, 0) == -1) {
 346                                         warn("sysctl version string");
 347                                         punt();
 348                                 }
 349                                 data.data = kv;
 350                         } else
 351                                 data.data = strdup(&mappedfile[nbuf.n_value -
 352                                     shdrp[symp[i].st_shndx].sh_addr +
 353                                     shdrp[symp[i].st_shndx].sh_offset]);
 354                         /* assumes newline terminates version. */
 355                         if ((tmpcp = strchr(data.data, '\n')) != NULL)
 356                                 *tmpcp = '\0';
 357                         data.size = strlen((char *)data.data);
 358
 359                         if (db->put(db, &key, &data, 0)) {
 360                                 warn("record enter");
 361                                 punt();
 362                         }
 363
 364                         /* free pointer created by strdup(). */
 365                         free(data.data);
 366
 367                         /* Restore to original values */
 368                         data.data = (u_char *)&nbuf;
 369                         data.size = sizeof(nbuf);
 370                 }
 371         }
 372
 373         rv = 0;
 374
 375 unmap:
 376         if (malloced)
 377                 free(mappedfile);
 378         else
 379                 munmap(mappedfile, mappedsize);
 380 out:
 381         return (rv);
 382 }
 383
 384 #endif