libdw/dwarf_begin_elf.c

   1 /* Create descriptor from ELF descriptor for processing file.
   2    Copyright (C) 2002-2011 Red Hat, Inc.
   3    This file is part of Red Hat elfutils.
   4    Written by Ulrich Drepper <drepper@redhat.com>, 2002.
   5
   6    Red Hat elfutils is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; version 2 of the License.
   9
  10    Red Hat elfutils is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License along
  16    with Red Hat elfutils; if not, write to the Free Software Foundation,
  17    Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
  18
  19    In addition, as a special exception, Red Hat, Inc. gives You the
  20    additional right to link the code of Red Hat elfutils with code licensed
  21    under any Open Source Initiative certified open source license
  22    (http://www.opensource.org/licenses/index.php) which requires the
  23    distribution of source code with any binary distribution and to
  24    distribute linked combinations of the two.  Non-GPL Code permitted under
  25    this exception must only link to the code of Red Hat elfutils through
  26    those well defined interfaces identified in the file named EXCEPTION
  27    found in the source code files (the "Approved Interfaces").  The files
  28    of Non-GPL Code may instantiate templates or use macros or inline
  29    functions from the Approved Interfaces without causing the resulting
  30    work to be covered by the GNU General Public License.  Only Red Hat,
  31    Inc. may make changes or additions to the list of Approved Interfaces.
  32    Red Hat's grant of this exception is conditioned upon your not adding
  33    any new exceptions.  If you wish to add a new Approved Interface or
  34    exception, please contact Red Hat.  You must obey the GNU General Public
  35    License in all respects for all of the Red Hat elfutils code and other
  36    code used in conjunction with Red Hat elfutils except the Non-GPL Code
  37    covered by this exception.  If you modify this file, you may extend this
  38    exception to your version of the file, but you are not obligated to do
  39    so.  If you do not wish to provide this exception without modification,
  40    you must delete this exception statement from your version and license
  41    this file solely under the GPL without exception.
  42
  43    Red Hat elfutils is an included package of the Open Invention Network.
  44    An included package of the Open Invention Network is a package for which
  45    Open Invention Network licensees cross-license their patents.  No patent
  46    license is granted, either expressly or impliedly, by designation as an
  47    included package.  Should you wish to participate in the Open Invention
  48    Network licensing program, please visit www.openinventionnetwork.com
  49    <http://www.openinventionnetwork.com>.  */
  50
  51 #ifdef HAVE_CONFIG_H
  52 # include <config.h>
  53 #endif
  54
  55 #include <stdbool.h>
  56 #include <stddef.h>
  57 #include <stdlib.h>
  58 #include <string.h>
  59 #include <unistd.h>
  60 #include <sys/stat.h>
  61
  62 #include "libdwP.h"
  63
  64 #if USE_ZLIB
  65 # include <endian.h>
  66 # define crc32          loser_crc32
  67 # include <zlib.h>
  68 # undef crc32
  69 #endif
  70
  71
  72 /* Section names.  */
  73 static const char dwarf_scnnames[IDX_last][17] =
  74 {
  75   [IDX_debug_info] = ".debug_info",
  76   [IDX_debug_types] = ".debug_types",
  77   [IDX_debug_abbrev] = ".debug_abbrev",
  78   [IDX_debug_aranges] = ".debug_aranges",
  79   [IDX_debug_line] = ".debug_line",
  80   [IDX_debug_frame] = ".debug_frame",
  81   [IDX_debug_loc] = ".debug_loc",
  82   [IDX_debug_pubnames] = ".debug_pubnames",
  83   [IDX_debug_str] = ".debug_str",
  84   [IDX_debug_macinfo] = ".debug_macinfo",
  85   [IDX_debug_ranges] = ".debug_ranges"
  86 };
  87 #define ndwarf_scnnames (sizeof (dwarf_scnnames) / sizeof (dwarf_scnnames[0]))
  88
  89
  90 static Dwarf *
  91 check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn, bool inscngrp)
  92 {
  93   GElf_Shdr shdr_mem;
  94   GElf_Shdr *shdr;
  95
  96   /* Get the section header data.  */
  97   shdr = gelf_getshdr (scn, &shdr_mem);
  98   if (shdr == NULL)
  99     /* This should never happen.  If it does something is
 100        wrong in the libelf library.  */
 101     abort ();
 102
 103   /* Ignore any SHT_NOBITS sections.  Debugging sections should not
 104      have been stripped, but in case of a corrupt file we won't try
 105      to look at the missing data.  */
 106   if (unlikely (shdr->sh_type == SHT_NOBITS))
 107     return result;
 108
 109   /* Make sure the section is part of a section group only iff we
 110      really need it.  If we are looking for the global (= non-section
 111      group debug info) we have to ignore all the info in section
 112      groups.  If we are looking into a section group we cannot look at
 113      a section which isn't part of the section group.  */
 114   if (! inscngrp && (shdr->sh_flags & SHF_GROUP) != 0)
 115     /* Ignore the section.  */
 116     return result;
 117
 118
 119   /* We recognize the DWARF section by their names.  This is not very
 120      safe and stable but the best we can do.  */
 121   const char *scnname = elf_strptr (result->elf, ehdr->e_shstrndx,
 122                                     shdr->sh_name);
 123   if (scnname == NULL)
 124     {
 125       /* The section name must be valid.  Otherwise is the ELF file
 126          invalid.  */
 127       __libdw_free_zdata (result);
 128       __libdw_seterrno (DWARF_E_INVALID_ELF);
 129       free (result);
 130       return NULL;
 131     }
 132
 133
 134   /* Recognize the various sections.  Most names start with .debug_.  */
 135   size_t cnt;
 136   for (cnt = 0; cnt < ndwarf_scnnames; ++cnt)
 137     if (strcmp (scnname, dwarf_scnnames[cnt]) == 0)
 138       {
 139         /* Found it.  Remember where the data is.  */
 140         if (unlikely (result->sectiondata[cnt] != NULL))
 141           /* A section appears twice.  That's bad.  We ignore the section.  */
 142           break;
 143
 144         /* Get the section data.  */
 145         Elf_Data *data = elf_getdata (scn, NULL);
 146         if (data != NULL && data->d_size != 0)
 147           /* Yep, there is actually data available.  */
 148           result->sectiondata[cnt] = data;
 149
 150         break;
 151       }
 152 #if USE_ZLIB
 153     else if (scnname[0] == '.' && scnname[1] == 'z'
 154              && strcmp (&scnname[2], &dwarf_scnnames[cnt][1]) == 0)
 155       {
 156         /* A compressed section.  */
 157
 158         if (unlikely (result->sectiondata[cnt] != NULL))
 159           /* A section appears twice.  That's bad.  We ignore the section.  */
 160           break;
 161
 162         /* Get the section data.  */
 163         Elf_Data *data = elf_getdata (scn, NULL);
 164         if (data != NULL && data->d_size != 0)
 165           {
 166             /* There is a 12-byte header of "ZLIB" followed by
 167                an 8-byte big-endian size.  */
 168
 169             if (unlikely (data->d_size < 4 + 8)
 170                 || unlikely (memcmp (data->d_buf, "ZLIB", 4) != 0))
 171               break;
 172
 173             uint64_t size;
 174             memcpy (&size, data->d_buf + 4, sizeof size);
 175             size = be64toh (size);
 176
 177             Elf_Data *zdata = malloc (sizeof (Elf_Data) + size);
 178             if (unlikely (zdata == NULL))
 179               break;
 180
 181             zdata->d_buf = &zdata[1];
 182             zdata->d_type = ELF_T_BYTE;
 183             zdata->d_version = EV_CURRENT;
 184             zdata->d_size = size;
 185             zdata->d_off = 0;
 186             zdata->d_align = 1;
 187
 188             z_stream z =
 189               {
 190                 .next_in = data->d_buf + 4 + 8,
 191                 .avail_in = data->d_size - 4 - 8,
 192                 .next_out = zdata->d_buf,
 193                 .avail_out = zdata->d_size
 194               };
 195             int zrc = inflateInit (&z);
 196             while (z.avail_in > 0 && likely (zrc == Z_OK))
 197               {
 198                 z.next_out = zdata->d_buf + (zdata->d_size - z.avail_out);
 199                 zrc = inflate (&z, Z_FINISH);
 200                 if (unlikely (zrc != Z_STREAM_END))
 201                   {
 202                     zrc = Z_DATA_ERROR;
 203                     break;
 204                   }
 205                 zrc = inflateReset (&z);
 206               }
 207             if (likely (zrc == Z_OK))
 208               zrc = inflateEnd (&z);
 209
 210             if (unlikely (zrc != Z_OK) || unlikely (z.avail_out != 0))
 211               free (zdata);
 212             else
 213               {
 214                 result->sectiondata[cnt] = zdata;
 215                 result->sectiondata_gzip_mask |= 1U << cnt;
 216               }
 217           }
 218
 219         break;
 220       }
 221 #endif
 222
 223   return result;
 224 }
 225
 226
 227 /* Check whether all the necessary DWARF information is available.  */
 228 static Dwarf *
 229 valid_p (Dwarf *result)
 230 {
 231   /* We looked at all the sections.  Now determine whether all the
 232      sections with debugging information we need are there.
 233
 234      XXX Which sections are absolutely necessary?  Add tests if
 235      necessary.  For now we require only .debug_info.  Hopefully this
 236      is correct.  */
 237   if (likely (result != NULL)
 238       && unlikely (result->sectiondata[IDX_debug_info] == NULL))
 239     {
 240       __libdw_free_zdata (result);
 241       __libdw_seterrno (DWARF_E_NO_DWARF);
 242       free (result);
 243       result = NULL;
 244     }
 245
 246   return result;
 247 }
 248
 249
 250 static Dwarf *
 251 global_read (Dwarf *result, Elf *elf, GElf_Ehdr *ehdr)
 252 {
 253   Elf_Scn *scn = NULL;
 254
 255   while (result != NULL && (scn = elf_nextscn (elf, scn)) != NULL)
 256     result = check_section (result, ehdr, scn, false);
 257
 258   return valid_p (result);
 259 }
 260
 261
 262 static Dwarf *
 263 scngrp_read (Dwarf *result, Elf *elf, GElf_Ehdr *ehdr, Elf_Scn *scngrp)
 264 {
 265   /* SCNGRP is the section descriptor for a section group which might
 266      contain debug sections.  */
 267   Elf_Data *data = elf_getdata (scngrp, NULL);
 268   if (data == NULL)
 269     {
 270       /* We cannot read the section content.  Fail!  */
 271       __libdw_free_zdata (result);
 272       free (result);
 273       return NULL;
 274     }
 275
 276   /* The content of the section is a number of 32-bit words which
 277      represent section indices.  The first word is a flag word.  */
 278   Elf32_Word *scnidx = (Elf32_Word *) data->d_buf;
 279   size_t cnt;
 280   for (cnt = 1; cnt * sizeof (Elf32_Word) <= data->d_size; ++cnt)
 281     {
 282       Elf_Scn *scn = elf_getscn (elf, scnidx[cnt]);
 283       if (scn == NULL)
 284         {
 285           /* A section group refers to a non-existing section.  Should
 286              never happen.  */
 287           __libdw_free_zdata (result);
 288           __libdw_seterrno (DWARF_E_INVALID_ELF);
 289           free (result);
 290           return NULL;
 291         }
 292
 293       result = check_section (result, ehdr, scn, true);
 294       if (result == NULL)
 295         break;
 296     }
 297
 298   return valid_p (result);
 299 }
 300
 301
 302 Dwarf *
 303 dwarf_begin_elf (elf, cmd, scngrp)
 304      Elf *elf;
 305      Dwarf_Cmd cmd;
 306      Elf_Scn *scngrp;
 307 {
 308   GElf_Ehdr *ehdr;
 309   GElf_Ehdr ehdr_mem;
 310
 311   /* Get the ELF header of the file.  We need various pieces of
 312      information from it.  */
 313   ehdr = gelf_getehdr (elf, &ehdr_mem);
 314   if (ehdr == NULL)
 315     {
 316       if (elf_kind (elf) != ELF_K_ELF)
 317         __libdw_seterrno (DWARF_E_NOELF);
 318       else
 319         __libdw_seterrno (DWARF_E_GETEHDR_ERROR);
 320
 321       return NULL;
 322     }
 323
 324
 325   /* Default memory allocation size.  */
 326   size_t mem_default_size = sysconf (_SC_PAGESIZE) - 4 * sizeof (void *);
 327
 328   /* Allocate the data structure.  */
 329   Dwarf *result = (Dwarf *) calloc (1, sizeof (Dwarf) + mem_default_size);
 330   if (unlikely (result == NULL)
 331       || unlikely (Dwarf_Sig8_Hash_init (&result->sig8_hash, 11) < 0))
 332     {
 333       free (result);
 334       __libdw_seterrno (DWARF_E_NOMEM);
 335       return NULL;
 336     }
 337
 338   /* Fill in some values.  */
 339   if ((BYTE_ORDER == LITTLE_ENDIAN && ehdr->e_ident[EI_DATA] == ELFDATA2MSB)
 340       || (BYTE_ORDER == BIG_ENDIAN && ehdr->e_ident[EI_DATA] == ELFDATA2LSB))
 341     result->other_byte_order = true;
 342
 343   result->elf = elf;
 344
 345   /* Initialize the memory handling.  */
 346   result->mem_default_size = mem_default_size;
 347   result->oom_handler = __libdw_oom;
 348   result->mem_tail = (struct libdw_memblock *) (result + 1);
 349   result->mem_tail->size = (result->mem_default_size
 350                             - offsetof (struct libdw_memblock, mem));
 351   result->mem_tail->remaining = result->mem_tail->size;
 352   result->mem_tail->prev = NULL;
 353
 354   if (cmd == DWARF_C_READ || cmd == DWARF_C_RDWR)
 355     {
 356       /* If the caller provides a section group we get the DWARF
 357          sections only from this setion group.  Otherwise we search
 358          for the first section with the required name.  Further
 359          sections with the name are ignored.  The DWARF specification
 360          does not really say this is allowed.  */
 361       if (scngrp == NULL)
 362         return global_read (result, elf, ehdr);
 363       else
 364         return scngrp_read (result, elf, ehdr, scngrp);
 365     }
 366   else if (cmd == DWARF_C_WRITE)
 367     {
 368       __libdw_seterrno (DWARF_E_UNIMPL);
 369       free (result);
 370       return NULL;
 371     }
 372
 373   __libdw_seterrno (DWARF_E_INVALID_CMD);
 374   free (result);
 375   return NULL;
 376 }
 377 INTDEF(dwarf_begin_elf)