lib/libc/gen/nlist_elf32.c

   1 /* $NetBSD: nlist_elf32.c,v 1.35 2012/03/21 02:18:14 christos 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 #if defined(LIBC_SCCS) && !defined(lint)
  39 __RCSID("$NetBSD: nlist_elf32.c,v 1.35 2012/03/21 02:18:14 christos Exp $");
  40 #endif /* LIBC_SCCS and 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 "namespace.h"
  48 #include <sys/param.h>
  49 #include <sys/mman.h>
  50 #include <sys/stat.h>
  51 #include <sys/file.h>
  52 #include <sys/ioctl.h>
  53 #include <sys/ksyms.h>
  54
  55 #include <assert.h>
  56 #include <errno.h>
  57 #include <stdio.h>
  58 #include <string.h>
  59 #include <unistd.h>
  60 #include <nlist.h>
  61
  62 #include "nlist_private.h"
  63 #if defined(NLIST_ELF32) || defined(NLIST_ELF64)
  64 #include <sys/exec_elf.h>
  65 #endif
  66
  67 #if (defined(NLIST_ELF32) && (ELFSIZE == 32)) || \
  68     (defined(NLIST_ELF64) && (ELFSIZE == 64))
  69
  70 /* No need to check for off < 0 because it is unsigned */
  71 #define check(off, size)        (off + size > mappedsize)
  72 #define BAD                     goto out
  73 #define BADUNMAP                goto unmap
  74
  75 int
  76 ELFNAMEEND(__fdnlist)(int fd, struct nlist *list)
  77 {
  78         struct stat st;
  79         Elf_Ehdr ehdr;
  80 #if _LP64 || ELFSIZE == 32
  81 #if (ELFSIZE == 32)
  82         Elf32_Half nshdr;
  83 #elif (ELFSIZE == 64)
  84         Elf64_Word nshdr;
  85 #endif
  86         /* Only support 64+32 mode on LP64; no support for 64 mode on ILP32 */
  87         Elf_Ehdr *ehdrp;
  88         Elf_Shdr *shdrp, *symshdrp, *symstrshdrp;
  89         Elf_Sym *symp;
  90         Elf_Off shdr_off;
  91         Elf_Word shdr_size;
  92         struct nlist *p;
  93         char *mappedfile, *strtab;
  94         size_t mappedsize, nsyms;
  95         int nent;
  96 #endif
  97         int rv;
  98         size_t i;
  99
 100         _DIAGASSERT(fd != -1);
 101         _DIAGASSERT(list != NULL);
 102
 103         rv = -1;
 104
 105         /*
 106          * If we can't fstat() the file, something bad is going on.
 107          */
 108         if (fstat(fd, &st) < 0)
 109                 BAD;
 110
 111         /*
 112          * Map the file in its entirety.
 113          */
 114         if ((uintmax_t)st.st_size > (uintmax_t)SIZE_T_MAX) {
 115                 errno = EFBIG;
 116                 BAD;
 117         }
 118
 119         /*
 120          * Read the elf header of the file.
 121          */
 122         if ((ssize_t)(i = pread(fd, &ehdr, sizeof(Elf_Ehdr), (off_t)0)) == -1)
 123                 BAD;
 124
 125         /*
 126          * Check that the elf header is correct.
 127          */
 128         if (i != sizeof(Elf_Ehdr))
 129                 BAD;
 130         if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 ||
 131             ehdr.e_ident[EI_CLASS] != ELFCLASS)
 132                 BAD;
 133
 134         switch (ehdr.e_machine) {
 135         ELFDEFNNAME(MACHDEP_ID_CASES)
 136
 137         default:
 138                 BAD;
 139         }
 140 #if _LP64 || ELFSIZE == 32
 141         symshdrp = symstrshdrp = NULL;
 142
 143         /* Only support 64+32 mode on LP64; no support for 64 mode on ILP32 */
 144         if (S_ISCHR(st.st_mode)) {
 145                 const char *nlistname;
 146                 struct ksyms_gsymbol kg;
 147                 Elf_Sym sym;
 148
 149                 /*
 150                  * Character device; assume /dev/ksyms.
 151                  */
 152                 nent = 0;
 153                 for (p = list; !ISLAST(p); ++p) {
 154
 155                         p->n_other = 0;
 156                         p->n_desc = 0;
 157                         nlistname = N_NAME(p);
 158                         if (*nlistname == '_')
 159                                 nlistname++;
 160
 161                         kg.kg_name = nlistname;
 162                         kg.kg_sym = &sym;
 163                         if (ioctl(fd, KIOCGSYMBOL, &kg) == 0) {
 164                                 p->n_value = (uintptr_t)sym.st_value;
 165                                 switch (ELF_ST_TYPE(sym.st_info)) {
 166                                 case STT_NOTYPE:
 167                                         p->n_type = N_UNDF;
 168                                         break;
 169                                 case STT_COMMON:
 170                                 case STT_OBJECT:
 171                                         p->n_type = N_DATA;
 172                                         break;
 173                                 case STT_FUNC:
 174                                         p->n_type = N_TEXT;
 175                                         break;
 176                                 case STT_FILE:
 177                                         p->n_type = N_FN;
 178                                         break;
 179                                 default:
 180                                         p->n_type = 0;
 181                                         /* catch other enumerations for gcc */
 182                                         break;
 183                                 }
 184                                 if (ELF_ST_BIND(sym.st_info) != STB_LOCAL)
 185                                         p->n_type |= N_EXT;
 186                         } else {
 187                                 nent++;
 188                                 p->n_value = 0;
 189                                 p->n_type = 0;
 190                         }
 191                 }
 192                 return nent;
 193         }
 194
 195         mappedsize = (size_t)st.st_size;
 196         mappedfile = mmap(NULL, mappedsize, PROT_READ, MAP_PRIVATE|MAP_FILE,
 197             fd, (off_t)0);
 198         if (mappedfile == (char *)-1)
 199                 BAD;
 200
 201         /*
 202          * Make sure we can access the executable's header
 203          * directly, and make sure the recognize the executable
 204          * as an ELF binary.
 205          */
 206         if (check(0, sizeof *ehdrp))
 207                 BADUNMAP;
 208         ehdrp = (Elf_Ehdr *)(void *)&mappedfile[0];
 209
 210         /*
 211          * Find the symbol list and string table.
 212          */
 213         nshdr = ehdrp->e_shnum;
 214         shdr_off = ehdrp->e_shoff;
 215         shdr_size = ehdrp->e_shentsize * nshdr;
 216
 217         if (check(shdr_off, shdr_size) ||
 218             (sizeof *shdrp != ehdrp->e_shentsize))
 219                 BADUNMAP;
 220         shdrp = (void *)&mappedfile[(size_t)shdr_off];
 221
 222         for (i = 0; i < nshdr; i++) {
 223                 if (shdrp[i].sh_type == SHT_SYMTAB) {
 224                         symshdrp = &shdrp[i];
 225                         symstrshdrp = &shdrp[shdrp[i].sh_link];
 226                 }
 227         }
 228
 229         /* Make sure we're not stripped. */
 230         if (symshdrp == NULL || symshdrp->sh_offset == 0)
 231                 BADUNMAP;
 232
 233         /* Make sure the symbols and strings are safely mapped. */
 234         if (check(symshdrp->sh_offset, symshdrp->sh_size))
 235                 BADUNMAP;
 236         if (check(symstrshdrp->sh_offset, symstrshdrp->sh_size))
 237                 BADUNMAP;
 238
 239         symp = (void *)&mappedfile[(size_t)symshdrp->sh_offset];
 240         nsyms = (size_t)(symshdrp->sh_size / sizeof(*symp));
 241         strtab = &mappedfile[(size_t)symstrshdrp->sh_offset];
 242
 243         /*
 244          * Clean out any left-over information for all valid entries.
 245          * Type and value are defined to be 0 if not found; historical
 246          * versions cleared other and desc as well.
 247          *
 248          * XXX Clearing anything other than n_type and n_value violates
 249          * the semantics given in the man page.
 250          */
 251         nent = 0;
 252         for (p = list; !ISLAST(p); ++p) {
 253                 p->n_type = 0;
 254                 p->n_other = 0;
 255                 p->n_desc = 0;
 256                 p->n_value = 0;
 257                 ++nent;
 258         }
 259
 260         for (i = 0; i < nsyms; i++) {
 261                 for (p = list; !ISLAST(p); ++p) {
 262                         const char *nlistname;
 263                         char *symtabname;
 264
 265                         /* This may be incorrect */
 266                         nlistname = N_NAME(p);
 267                         if (*nlistname == '_')
 268                                 nlistname++;
 269
 270                         symtabname = &strtab[symp[i].st_name];
 271
 272                         if (!strcmp(symtabname, nlistname)) {
 273                                 /*
 274                                  * Translate (roughly) from ELF to nlist
 275                                  */
 276                                 p->n_value = (uintptr_t)symp[i].st_value;
 277                                 switch (ELF_ST_TYPE(symp[i].st_info)) {
 278                                 case STT_NOTYPE:
 279                                         p->n_type = N_UNDF;
 280                                         break;
 281                                 case STT_OBJECT:
 282                                 case STT_COMMON:
 283                                         p->n_type = N_DATA;
 284                                         break;
 285                                 case STT_FUNC:
 286                                         p->n_type = N_TEXT;
 287                                         break;
 288                                 case STT_FILE:
 289                                         p->n_type = N_FN;
 290                                         break;
 291                                 default:
 292                                         /* catch other enumerations for gcc */
 293                                         break;
 294                                 }
 295                                 if (ELF_ST_BIND(symp[i].st_info) != STB_LOCAL)
 296                                         p->n_type |= N_EXT;
 297                                 p->n_desc = 0;                  /* XXX */
 298                                 p->n_other = 0;                 /* XXX */
 299
 300                                 if (--nent <= 0)
 301                                         goto done;
 302                                 break;  /* into next run of outer loop */
 303                         }
 304                 }
 305         }
 306
 307 done:
 308         rv = nent;
 309 unmap:
 310         munmap(mappedfile, mappedsize);
 311 #endif /* _LP64 || ELFSIZE == 32 */
 312 out:
 313         return (rv);
 314 }
 315
 316 #endif