libdw/dwarf_begin_elf.c

   1 /* Create descriptor from ELF descriptor for processing file.
   2    Copyright (C) 2002-2011, 2014, 2015 Red Hat, Inc.
   3    This file is part of elfutils.
   4    Written by Ulrich Drepper <drepper@redhat.com>, 2002.
   5
   6    This file is free software; you can redistribute it and/or modify
   7    it under the terms of either
   8
   9      * the GNU Lesser General Public License as published by the Free
  10        Software Foundation; either version 3 of the License, or (at
  11        your option) any later version
  12
  13    or
  14
  15      * the GNU General Public License as published by the Free
  16        Software Foundation; either version 2 of the License, or (at
  17        your option) any later version
  18
  19    or both in parallel, as here.
  20
  21    elfutils is distributed in the hope that it will be useful, but
  22    WITHOUT ANY WARRANTY; without even the implied warranty of
  23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24    General Public License for more details.
  25
  26    You should have received copies of the GNU General Public License and
  27    the GNU Lesser General Public License along with this program.  If
  28    not, see <http://www.gnu.org/licenses/>.  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include <config.h>
  32 #endif
  33
  34 #include <assert.h>
  35 #include <stdbool.h>
  36 #include <stddef.h>
  37 #include <stdlib.h>
  38 #include <stdio.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #include <sys/types.h>
  42 #include <sys/stat.h>
  43 #include <fcntl.h>
  44
  45 #include "libdwP.h"
  46
  47
  48 /* Section names.  */
  49 static const char dwarf_scnnames[IDX_last][18] =
  50 {
  51   [IDX_debug_info] = ".debug_info",
  52   [IDX_debug_types] = ".debug_types",
  53   [IDX_debug_abbrev] = ".debug_abbrev",
  54   [IDX_debug_aranges] = ".debug_aranges",
  55   [IDX_debug_line] = ".debug_line",
  56   [IDX_debug_frame] = ".debug_frame",
  57   [IDX_debug_loc] = ".debug_loc",
  58   [IDX_debug_pubnames] = ".debug_pubnames",
  59   [IDX_debug_str] = ".debug_str",
  60   [IDX_debug_macinfo] = ".debug_macinfo",
  61   [IDX_debug_macro] = ".debug_macro",
  62   [IDX_debug_ranges] = ".debug_ranges",
  63   [IDX_gnu_debugaltlink] = ".gnu_debugaltlink"
  64 };
  65 #define ndwarf_scnnames (sizeof (dwarf_scnnames) / sizeof (dwarf_scnnames[0]))
  66
  67 static Dwarf *
  68 check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn, bool inscngrp)
  69 {
  70   GElf_Shdr shdr_mem;
  71   GElf_Shdr *shdr;
  72
  73   /* Get the section header data.  */
  74   shdr = gelf_getshdr (scn, &shdr_mem);
  75   if (shdr == NULL)
  76     /* We may read /proc/PID/mem with only program headers mapped and section
  77        headers out of the mapped pages.  */
  78     goto err;
  79
  80   /* Ignore any SHT_NOBITS sections.  Debugging sections should not
  81      have been stripped, but in case of a corrupt file we won't try
  82      to look at the missing data.  */
  83   if (unlikely (shdr->sh_type == SHT_NOBITS))
  84     return result;
  85
  86   /* Make sure the section is part of a section group only iff we
  87      really need it.  If we are looking for the global (= non-section
  88      group debug info) we have to ignore all the info in section
  89      groups.  If we are looking into a section group we cannot look at
  90      a section which isn't part of the section group.  */
  91   if (! inscngrp && (shdr->sh_flags & SHF_GROUP) != 0)
  92     /* Ignore the section.  */
  93     return result;
  94
  95
  96   /* We recognize the DWARF section by their names.  This is not very
  97      safe and stable but the best we can do.  */
  98   const char *scnname = elf_strptr (result->elf, ehdr->e_shstrndx,
  99                                     shdr->sh_name);
 100   if (scnname == NULL)
 101     {
 102       /* The section name must be valid.  Otherwise is the ELF file
 103          invalid.  */
 104     err:
 105       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 106       __libdw_seterrno (DWARF_E_INVALID_ELF);
 107       free (result);
 108       return NULL;
 109     }
 110
 111   /* Recognize the various sections.  Most names start with .debug_.  */
 112   size_t cnt;
 113   bool gnu_compressed = false;
 114   for (cnt = 0; cnt < ndwarf_scnnames; ++cnt)
 115     if (strcmp (scnname, dwarf_scnnames[cnt]) == 0)
 116       break;
 117     else if (scnname[0] == '.' && scnname[1] == 'z'
 118              && strcmp (&scnname[2], &dwarf_scnnames[cnt][1]) == 0)
 119       {
 120         gnu_compressed = true;
 121         break;
 122       }
 123
 124   if (cnt >= ndwarf_scnnames)
 125     /* Not a debug section; ignore it. */
 126     return result;
 127
 128   if (unlikely (result->sectiondata[cnt] != NULL))
 129     /* A section appears twice.  That's bad.  We ignore the section.  */
 130     return result;
 131
 132   /* We cannot know whether or not a GNU compressed section has already
 133      been uncompressed or not, so ignore any errors.  */
 134   if (gnu_compressed)
 135     elf_compress_gnu (scn, 0, 0);
 136
 137   if ((shdr->sh_flags & SHF_COMPRESSED) != 0)
 138     {
 139       if (elf_compress (scn, 0, 0) < 0)
 140         {
 141           /* If we failed to decompress the section and it's the
 142              debug_info section, then fail with specific error rather
 143              than the generic NO_DWARF. Without debug_info we can't do
 144              anything (see also valid_p()). */
 145           if (cnt == IDX_debug_info)
 146             {
 147               Dwarf_Sig8_Hash_free (&result->sig8_hash);
 148               __libdw_seterrno (DWARF_E_COMPRESSED_ERROR);
 149               free (result);
 150               return NULL;
 151             }
 152           return result;
 153         }
 154     }
 155
 156   /* Get the section data.  */
 157   Elf_Data *data = elf_getdata (scn, NULL);
 158   if (data == NULL)
 159     goto err;
 160
 161   if (data->d_buf == NULL || data->d_size == 0)
 162     /* No data actually available, ignore it. */
 163     return result;
 164
 165   /* We can now read the section data into results. */
 166   result->sectiondata[cnt] = data;
 167
 168   return result;
 169 }
 170
 171
 172 /* Check whether all the necessary DWARF information is available.  */
 173 static Dwarf *
 174 valid_p (Dwarf *result)
 175 {
 176   /* We looked at all the sections.  Now determine whether all the
 177      sections with debugging information we need are there.
 178
 179      XXX Which sections are absolutely necessary?  Add tests if
 180      necessary.  For now we require only .debug_info.  Hopefully this
 181      is correct.  */
 182   if (likely (result != NULL)
 183       && unlikely (result->sectiondata[IDX_debug_info] == NULL))
 184     {
 185       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 186       __libdw_seterrno (DWARF_E_NO_DWARF);
 187       free (result);
 188       result = NULL;
 189     }
 190
 191   if (result != NULL && result->sectiondata[IDX_debug_loc] != NULL)
 192     {
 193       result->fake_loc_cu = (Dwarf_CU *) calloc (1, sizeof (Dwarf_CU));
 194       if (unlikely (result->fake_loc_cu == NULL))
 195         {
 196           Dwarf_Sig8_Hash_free (&result->sig8_hash);
 197           __libdw_seterrno (DWARF_E_NOMEM);
 198           free (result);
 199           result = NULL;
 200         }
 201       else
 202         {
 203           result->fake_loc_cu->dbg = result;
 204           result->fake_loc_cu->startp
 205             = result->sectiondata[IDX_debug_loc]->d_buf;
 206           result->fake_loc_cu->endp
 207             = (result->sectiondata[IDX_debug_loc]->d_buf
 208                + result->sectiondata[IDX_debug_loc]->d_size);
 209         }
 210     }
 211
 212   return result;
 213 }
 214
 215
 216 static Dwarf *
 217 global_read (Dwarf *result, Elf *elf, GElf_Ehdr *ehdr)
 218 {
 219   Elf_Scn *scn = NULL;
 220
 221   while (result != NULL && (scn = elf_nextscn (elf, scn)) != NULL)
 222     result = check_section (result, ehdr, scn, false);
 223
 224   return valid_p (result);
 225 }
 226
 227
 228 static Dwarf *
 229 scngrp_read (Dwarf *result, Elf *elf, GElf_Ehdr *ehdr, Elf_Scn *scngrp)
 230 {
 231   GElf_Shdr shdr_mem;
 232   GElf_Shdr *shdr = gelf_getshdr (scngrp, &shdr_mem);
 233   if (shdr == NULL)
 234     {
 235       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 236       __libdw_seterrno (DWARF_E_INVALID_ELF);
 237       free (result);
 238       return NULL;
 239     }
 240
 241   if ((shdr->sh_flags & SHF_COMPRESSED) != 0
 242       && elf_compress (scngrp, 0, 0) < 0)
 243     {
 244       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 245       __libdw_seterrno (DWARF_E_COMPRESSED_ERROR);
 246       free (result);
 247       return NULL;
 248     }
 249
 250   /* SCNGRP is the section descriptor for a section group which might
 251      contain debug sections.  */
 252   Elf_Data *data = elf_getdata (scngrp, NULL);
 253   if (data == NULL)
 254     {
 255       /* We cannot read the section content.  Fail!  */
 256       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 257       free (result);
 258       return NULL;
 259     }
 260
 261   /* The content of the section is a number of 32-bit words which
 262      represent section indices.  The first word is a flag word.  */
 263   Elf32_Word *scnidx = (Elf32_Word *) data->d_buf;
 264   size_t cnt;
 265   for (cnt = 1; cnt * sizeof (Elf32_Word) <= data->d_size; ++cnt)
 266     {
 267       Elf_Scn *scn = elf_getscn (elf, scnidx[cnt]);
 268       if (scn == NULL)
 269         {
 270           /* A section group refers to a non-existing section.  Should
 271              never happen.  */
 272           Dwarf_Sig8_Hash_free (&result->sig8_hash);
 273           __libdw_seterrno (DWARF_E_INVALID_ELF);
 274           free (result);
 275           return NULL;
 276         }
 277
 278       result = check_section (result, ehdr, scn, true);
 279       if (result == NULL)
 280         break;
 281     }
 282
 283   return valid_p (result);
 284 }
 285
 286
 287 Dwarf *
 288 dwarf_begin_elf (Elf *elf, Dwarf_Cmd cmd, Elf_Scn *scngrp)
 289 {
 290   GElf_Ehdr *ehdr;
 291   GElf_Ehdr ehdr_mem;
 292
 293   /* Get the ELF header of the file.  We need various pieces of
 294      information from it.  */
 295   ehdr = gelf_getehdr (elf, &ehdr_mem);
 296   if (ehdr == NULL)
 297     {
 298       if (elf_kind (elf) != ELF_K_ELF)
 299         __libdw_seterrno (DWARF_E_NOELF);
 300       else
 301         __libdw_seterrno (DWARF_E_GETEHDR_ERROR);
 302
 303       return NULL;
 304     }
 305
 306
 307   /* Default memory allocation size.  */
 308   size_t mem_default_size = sysconf (_SC_PAGESIZE) - 4 * sizeof (void *);
 309   assert (sizeof (struct Dwarf) < mem_default_size);
 310
 311   /* Allocate the data structure.  */
 312   Dwarf *result = (Dwarf *) calloc (1, sizeof (Dwarf) + mem_default_size);
 313   if (unlikely (result == NULL)
 314       || unlikely (Dwarf_Sig8_Hash_init (&result->sig8_hash, 11) < 0))
 315     {
 316       free (result);
 317       __libdw_seterrno (DWARF_E_NOMEM);
 318       return NULL;
 319     }
 320
 321   /* Fill in some values.  */
 322   if ((BYTE_ORDER == LITTLE_ENDIAN && ehdr->e_ident[EI_DATA] == ELFDATA2MSB)
 323       || (BYTE_ORDER == BIG_ENDIAN && ehdr->e_ident[EI_DATA] == ELFDATA2LSB))
 324     result->other_byte_order = true;
 325
 326   result->elf = elf;
 327
 328   /* Initialize the memory handling.  */
 329   result->mem_default_size = mem_default_size;
 330   result->oom_handler = __libdw_oom;
 331   result->mem_tail = (struct libdw_memblock *) (result + 1);
 332   result->mem_tail->size = (result->mem_default_size
 333                             - offsetof (struct libdw_memblock, mem));
 334   result->mem_tail->remaining = result->mem_tail->size;
 335   result->mem_tail->prev = NULL;
 336
 337   if (cmd == DWARF_C_READ || cmd == DWARF_C_RDWR)
 338     {
 339       /* If the caller provides a section group we get the DWARF
 340          sections only from this setion group.  Otherwise we search
 341          for the first section with the required name.  Further
 342          sections with the name are ignored.  The DWARF specification
 343          does not really say this is allowed.  */
 344       if (scngrp == NULL)
 345         return global_read (result, elf, ehdr);
 346       else
 347         return scngrp_read (result, elf, ehdr, scngrp);
 348     }
 349   else if (cmd == DWARF_C_WRITE)
 350     {
 351       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 352       __libdw_seterrno (DWARF_E_UNIMPL);
 353       free (result);
 354       return NULL;
 355     }
 356
 357   Dwarf_Sig8_Hash_free (&result->sig8_hash);
 358   __libdw_seterrno (DWARF_E_INVALID_CMD);
 359   free (result);
 360   return NULL;
 361 }
 362 INTDEF(dwarf_begin_elf)