libdw/dwarf_begin_elf.c

   1 /* Create descriptor from ELF descriptor for processing file.
   2    Copyright (C) 2002-2011, 2014, 2015, 2017, 2018 Red Hat, Inc.
   3    This file is part of elfutils.
   4
   5    This file is free software; you can redistribute it and/or modify
   6    it under the terms of either
   7
   8      * the GNU Lesser General Public License as published by the Free
   9        Software Foundation; either version 3 of the License, or (at
  10        your option) any later version
  11
  12    or
  13
  14      * the GNU General Public License as published by the Free
  15        Software Foundation; either version 2 of the License, or (at
  16        your option) any later version
  17
  18    or both in parallel, as here.
  19
  20    elfutils is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    General Public License for more details.
  24
  25    You should have received copies of the GNU General Public License and
  26    the GNU Lesser General Public License along with this program.  If
  27    not, see <http://www.gnu.org/licenses/>.  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include <config.h>
  31 #endif
  32
  33 #include <system.h>
  34
  35 #include <assert.h>
  36 #include <stdbool.h>
  37 #include <stddef.h>
  38 #include <stdlib.h>
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include <sys/types.h>
  42 #include <sys/stat.h>
  43 #include <fcntl.h>
  44
  45 #include "libelfP.h"
  46 #include "libdwP.h"
  47
  48
  49 /* Section names.  (Note .debug_str_offsets is the largest 19 chars.)  */
  50 static const char dwarf_scnnames[IDX_last][19] =
  51 {
  52   [IDX_debug_info] = ".debug_info",
  53   [IDX_debug_types] = ".debug_types",
  54   [IDX_debug_abbrev] = ".debug_abbrev",
  55   [IDX_debug_addr] = ".debug_addr",
  56   [IDX_debug_aranges] = ".debug_aranges",
  57   [IDX_debug_line] = ".debug_line",
  58   [IDX_debug_line_str] = ".debug_line_str",
  59   [IDX_debug_frame] = ".debug_frame",
  60   [IDX_debug_loc] = ".debug_loc",
  61   [IDX_debug_loclists] = ".debug_loclists",
  62   [IDX_debug_pubnames] = ".debug_pubnames",
  63   [IDX_debug_str] = ".debug_str",
  64   [IDX_debug_str_offsets] = ".debug_str_offsets",
  65   [IDX_debug_macinfo] = ".debug_macinfo",
  66   [IDX_debug_macro] = ".debug_macro",
  67   [IDX_debug_ranges] = ".debug_ranges",
  68   [IDX_debug_rnglists] = ".debug_rnglists",
  69   [IDX_gnu_debugaltlink] = ".gnu_debugaltlink"
  70 };
  71 #define ndwarf_scnnames (sizeof (dwarf_scnnames) / sizeof (dwarf_scnnames[0]))
  72
  73 static enum dwarf_type
  74 scn_dwarf_type (Dwarf *result, size_t shstrndx, Elf_Scn *scn)
  75 {
  76   GElf_Shdr shdr_mem;
  77   GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
  78   if (shdr == NULL)
  79     return TYPE_UNKNOWN;
  80
  81   const char *scnname = elf_strptr (result->elf, shstrndx,
  82                                     shdr->sh_name);
  83   if (scnname != NULL)
  84     {
  85       if (startswith (scnname, ".gnu.debuglto_.debug"))
  86         return TYPE_GNU_LTO;
  87       else if (startswith (scnname, ".debug_") || startswith (scnname, ".zdebug_"))
  88         {
  89           size_t len = strlen (scnname);
  90           if (strcmp (scnname + len - 4, ".dwo") == 0)
  91             return TYPE_DWO;
  92           else
  93             return TYPE_PLAIN;
  94         }
  95     }
  96   return TYPE_UNKNOWN;
  97 }
  98 static Dwarf *
  99 check_section (Dwarf *result, size_t shstrndx, Elf_Scn *scn, bool inscngrp)
 100 {
 101   GElf_Shdr shdr_mem;
 102   GElf_Shdr *shdr;
 103
 104   /* Get the section header data.  */
 105   shdr = gelf_getshdr (scn, &shdr_mem);
 106   if (shdr == NULL)
 107     /* We may read /proc/PID/mem with only program headers mapped and section
 108        headers out of the mapped pages.  */
 109     goto err;
 110
 111   /* Ignore any SHT_NOBITS sections.  Debugging sections should not
 112      have been stripped, but in case of a corrupt file we won't try
 113      to look at the missing data.  */
 114   if (unlikely (shdr->sh_type == SHT_NOBITS))
 115     return result;
 116
 117   /* Make sure the section is part of a section group only iff we
 118      really need it.  If we are looking for the global (= non-section
 119      group debug info) we have to ignore all the info in section
 120      groups.  If we are looking into a section group we cannot look at
 121      a section which isn't part of the section group.  */
 122   if (! inscngrp && (shdr->sh_flags & SHF_GROUP) != 0)
 123     /* Ignore the section.  */
 124     return result;
 125
 126
 127   /* We recognize the DWARF section by their names.  This is not very
 128      safe and stable but the best we can do.  */
 129   const char *scnname = elf_strptr (result->elf, shstrndx,
 130                                     shdr->sh_name);
 131   if (scnname == NULL)
 132     {
 133       /* The section name must be valid.  Otherwise is the ELF file
 134          invalid.  */
 135     err:
 136       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 137       __libdw_seterrno (DWARF_E_INVALID_ELF);
 138       free (result);
 139       return NULL;
 140     }
 141
 142   /* Recognize the various sections.  Most names start with .debug_.
 143      They might be compressed (and start with .z).  Or end with .dwo
 144      for split dwarf sections.  Or start with .gnu.debuglto_ for
 145      LTO debug sections.  We should only use one consistent set at
 146      a time.  We prefer PLAIN over DWO over LTO.  */
 147   size_t cnt;
 148   bool gnu_compressed = false;
 149   for (cnt = 0; cnt < ndwarf_scnnames; ++cnt)
 150     {
 151       size_t dbglen = strlen (dwarf_scnnames[cnt]);
 152       size_t scnlen = strlen (scnname);
 153       if (strncmp (scnname, dwarf_scnnames[cnt], dbglen) == 0
 154           && (dbglen == scnlen
 155               || (scnlen == dbglen + 4
 156                   && strstr (scnname, ".dwo") == scnname + dbglen)))
 157         {
 158           if (dbglen == scnlen)
 159             {
 160               if (result->type == TYPE_PLAIN)
 161                 break;
 162             }
 163           else if (result->type == TYPE_DWO)
 164             break;
 165         }
 166       else if (scnname[0] == '.' && scnname[1] == 'z'
 167                && (strncmp (&scnname[2], &dwarf_scnnames[cnt][1],
 168                             dbglen - 1) == 0
 169                    && (scnlen == dbglen + 1
 170                        || (scnlen == dbglen + 5
 171                            && strstr (scnname,
 172                                       ".dwo") == scnname + dbglen + 1))))
 173         {
 174           if (scnlen == dbglen + 1)
 175             {
 176               if (result->type == TYPE_PLAIN)
 177                 {
 178                   gnu_compressed = true;
 179                   break;
 180                 }
 181             }
 182           else if (result->type <= TYPE_DWO)
 183             {
 184               gnu_compressed = true;
 185               break;
 186             }
 187         }
 188       else if (scnlen > 14 /* .gnu.debuglto_ prefix. */
 189                && startswith (scnname, ".gnu.debuglto_")
 190                && strcmp (&scnname[14], dwarf_scnnames[cnt]) == 0)
 191         {
 192           if (result->type == TYPE_GNU_LTO)
 193             break;
 194         }
 195     }
 196
 197   if (cnt >= ndwarf_scnnames)
 198     /* Not a debug section; ignore it. */
 199     return result;
 200
 201   if (unlikely (result->sectiondata[cnt] != NULL))
 202     /* A section appears twice.  That's bad.  We ignore the section.  */
 203     return result;
 204
 205   /* We cannot know whether or not a GNU compressed section has already
 206      been uncompressed or not, so ignore any errors.  */
 207   if (gnu_compressed)
 208     elf_compress_gnu (scn, 0, 0);
 209
 210   if ((shdr->sh_flags & SHF_COMPRESSED) != 0)
 211     {
 212       if (elf_compress (scn, 0, 0) < 0)
 213         {
 214           /* It would be nice if we could fail with a specific error.
 215              But we don't know if this was an essential section or not.
 216              So just continue for now. See also valid_p().  */
 217           return result;
 218         }
 219     }
 220
 221   /* Get the section data.  */
 222   Elf_Data *data = elf_getdata (scn, NULL);
 223   if (data == NULL)
 224     goto err;
 225
 226   if (data->d_buf == NULL || data->d_size == 0)
 227     /* No data actually available, ignore it. */
 228     return result;
 229
 230   /* We can now read the section data into results. */
 231   result->sectiondata[cnt] = data;
 232
 233   return result;
 234 }
 235
 236
 237 /* Helper function to set debugdir field.  We want to cache the dir
 238    where we found this Dwarf ELF file to locate alt and dwo files.  */
 239 char *
 240 __libdw_debugdir (int fd)
 241 {
 242   /* strlen ("/proc/self/fd/") = 14 + strlen (<MAXINT>) = 10 + 1 = 25.  */
 243   char devfdpath[25];
 244   sprintf (devfdpath, "/proc/self/fd/%u", fd);
 245   char *fdpath = realpath (devfdpath, NULL);
 246   char *fddir;
 247   if (fdpath != NULL && fdpath[0] == '/'
 248       && (fddir = strrchr (fdpath, '/')) != NULL)
 249     {
 250       *++fddir = '\0';
 251       return fdpath;
 252     }
 253   return NULL;
 254 }
 255
 256
 257 /* Check whether all the necessary DWARF information is available.  */
 258 static Dwarf *
 259 valid_p (Dwarf *result)
 260 {
 261   /* We looked at all the sections.  Now determine whether all the
 262      sections with debugging information we need are there.
 263
 264      Require at least one section that can be read "standalone".  */
 265   if (likely (result != NULL)
 266       && unlikely (result->sectiondata[IDX_debug_info] == NULL
 267                    && result->sectiondata[IDX_debug_line] == NULL
 268                    && result->sectiondata[IDX_debug_frame] == NULL))
 269     {
 270       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 271       __libdw_seterrno (DWARF_E_NO_DWARF);
 272       free (result);
 273       result = NULL;
 274     }
 275
 276   /* We are setting up some "fake" CUs, which need an address size.
 277      Check the ELF class to come up with something reasonable.  */
 278   int elf_addr_size = 8;
 279   if (result != NULL)
 280     {
 281       GElf_Ehdr ehdr;
 282       if (gelf_getehdr (result->elf, &ehdr) == NULL)
 283         {
 284           Dwarf_Sig8_Hash_free (&result->sig8_hash);
 285           __libdw_seterrno (DWARF_E_INVALID_ELF);
 286           free (result);
 287           result = NULL;
 288         }
 289       else if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
 290         elf_addr_size = 4;
 291     }
 292
 293   /* For dwarf_location_attr () we need a "fake" CU to indicate
 294      where the "fake" attribute data comes from.  This is a block
 295      inside the .debug_loc or .debug_loclists section.  */
 296   if (result != NULL && result->sectiondata[IDX_debug_loc] != NULL)
 297     {
 298       result->fake_loc_cu = malloc (sizeof (Dwarf_CU));
 299       if (unlikely (result->fake_loc_cu == NULL))
 300         {
 301           Dwarf_Sig8_Hash_free (&result->sig8_hash);
 302           __libdw_seterrno (DWARF_E_NOMEM);
 303           free (result);
 304           result = NULL;
 305         }
 306       else
 307         {
 308           result->fake_loc_cu->sec_idx = IDX_debug_loc;
 309           result->fake_loc_cu->dbg = result;
 310           result->fake_loc_cu->startp
 311             = result->sectiondata[IDX_debug_loc]->d_buf;
 312           result->fake_loc_cu->endp
 313             = (result->sectiondata[IDX_debug_loc]->d_buf
 314                + result->sectiondata[IDX_debug_loc]->d_size);
 315           result->fake_loc_cu->locs = NULL;
 316           result->fake_loc_cu->address_size = elf_addr_size;
 317           result->fake_loc_cu->offset_size = 4;
 318           result->fake_loc_cu->version = 4;
 319           result->fake_loc_cu->split = NULL;
 320         }
 321     }
 322
 323   if (result != NULL && result->sectiondata[IDX_debug_loclists] != NULL)
 324     {
 325       result->fake_loclists_cu = malloc (sizeof (Dwarf_CU));
 326       if (unlikely (result->fake_loclists_cu == NULL))
 327         {
 328           Dwarf_Sig8_Hash_free (&result->sig8_hash);
 329           __libdw_seterrno (DWARF_E_NOMEM);
 330           free (result->fake_loc_cu);
 331           free (result);
 332           result = NULL;
 333         }
 334       else
 335         {
 336           result->fake_loclists_cu->sec_idx = IDX_debug_loclists;
 337           result->fake_loclists_cu->dbg = result;
 338           result->fake_loclists_cu->startp
 339             = result->sectiondata[IDX_debug_loclists]->d_buf;
 340           result->fake_loclists_cu->endp
 341             = (result->sectiondata[IDX_debug_loclists]->d_buf
 342                + result->sectiondata[IDX_debug_loclists]->d_size);
 343           result->fake_loclists_cu->locs = NULL;
 344           result->fake_loclists_cu->address_size = elf_addr_size;
 345           result->fake_loclists_cu->offset_size = 4;
 346           result->fake_loclists_cu->version = 5;
 347           result->fake_loclists_cu->split = NULL;
 348         }
 349     }
 350
 351   /* For DW_OP_constx/GNU_const_index and DW_OP_addrx/GNU_addr_index
 352      the dwarf_location_attr () will need a "fake" address CU to
 353      indicate where the attribute data comes from.  This is a just
 354      inside the .debug_addr section, if it exists.  */
 355   if (result != NULL && result->sectiondata[IDX_debug_addr] != NULL)
 356     {
 357       result->fake_addr_cu = malloc (sizeof (Dwarf_CU));
 358       if (unlikely (result->fake_addr_cu == NULL))
 359         {
 360           Dwarf_Sig8_Hash_free (&result->sig8_hash);
 361           __libdw_seterrno (DWARF_E_NOMEM);
 362           free (result->fake_loc_cu);
 363           free (result->fake_loclists_cu);
 364           free (result);
 365           result = NULL;
 366         }
 367       else
 368         {
 369           result->fake_addr_cu->sec_idx = IDX_debug_addr;
 370           result->fake_addr_cu->dbg = result;
 371           result->fake_addr_cu->startp
 372             = result->sectiondata[IDX_debug_addr]->d_buf;
 373           result->fake_addr_cu->endp
 374             = (result->sectiondata[IDX_debug_addr]->d_buf
 375                + result->sectiondata[IDX_debug_addr]->d_size);
 376           result->fake_addr_cu->locs = NULL;
 377           result->fake_addr_cu->address_size = elf_addr_size;
 378           result->fake_addr_cu->offset_size = 4;
 379           result->fake_addr_cu->version = 5;
 380           result->fake_addr_cu->split = NULL;
 381         }
 382     }
 383
 384   if (result != NULL)
 385     result->debugdir = __libdw_debugdir (result->elf->fildes);
 386
 387   return result;
 388 }
 389
 390
 391 static Dwarf *
 392 global_read (Dwarf *result, Elf *elf, size_t shstrndx)
 393 {
 394   Elf_Scn *scn = NULL;
 395
 396   /* First check the type (PLAIN, DWO, LTO) we are looking for.  We
 397      prefer PLAIN if available over DWO, over LTO.  */
 398   while ((scn = elf_nextscn (elf, scn)) != NULL && result->type != TYPE_PLAIN)
 399     {
 400       enum dwarf_type type = scn_dwarf_type (result, shstrndx, scn);
 401       if (type > result->type)
 402         result->type = type;
 403     }
 404
 405   scn = NULL;
 406   while (result != NULL && (scn = elf_nextscn (elf, scn)) != NULL)
 407     result = check_section (result, shstrndx, scn, false);
 408
 409   return valid_p (result);
 410 }
 411
 412
 413 static Dwarf *
 414 scngrp_read (Dwarf *result, Elf *elf, size_t shstrndx, Elf_Scn *scngrp)
 415 {
 416   GElf_Shdr shdr_mem;
 417   GElf_Shdr *shdr = gelf_getshdr (scngrp, &shdr_mem);
 418   if (shdr == NULL)
 419     {
 420       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 421       __libdw_seterrno (DWARF_E_INVALID_ELF);
 422       free (result);
 423       return NULL;
 424     }
 425
 426   if ((shdr->sh_flags & SHF_COMPRESSED) != 0
 427       && elf_compress (scngrp, 0, 0) < 0)
 428     {
 429       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 430       __libdw_seterrno (DWARF_E_COMPRESSED_ERROR);
 431       free (result);
 432       return NULL;
 433     }
 434
 435   /* SCNGRP is the section descriptor for a section group which might
 436      contain debug sections.  */
 437   Elf_Data *data = elf_getdata (scngrp, NULL);
 438   if (data == NULL)
 439     {
 440       /* We cannot read the section content.  Fail!  */
 441       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 442       free (result);
 443       return NULL;
 444     }
 445
 446   /* The content of the section is a number of 32-bit words which
 447      represent section indices.  The first word is a flag word.  */
 448   Elf32_Word *scnidx = (Elf32_Word *) data->d_buf;
 449   size_t cnt;
 450
 451   /* First check the type (PLAIN, DWO, LTO) we are looking for.  We
 452      prefer PLAIN if available over DWO, over LTO.  */
 453   for (cnt = 1; cnt * sizeof (Elf32_Word) <= data->d_size; ++cnt)
 454     {
 455       Elf_Scn *scn = elf_getscn (elf, scnidx[cnt]);
 456       if (scn == NULL)
 457         {
 458           /* A section group refers to a non-existing section.  Should
 459              never happen.  */
 460           Dwarf_Sig8_Hash_free (&result->sig8_hash);
 461           __libdw_seterrno (DWARF_E_INVALID_ELF);
 462           free (result);
 463           return NULL;
 464         }
 465
 466       enum dwarf_type type = scn_dwarf_type (result, shstrndx, scn);
 467       if (type > result->type)
 468         result->type = type;
 469     }
 470
 471   for (cnt = 1; cnt * sizeof (Elf32_Word) <= data->d_size && result != NULL; ++cnt)
 472     {
 473       Elf_Scn *scn = elf_getscn (elf, scnidx[cnt]);
 474       assert (scn != NULL); // checked above
 475       result = check_section (result, shstrndx, scn, true);
 476       if (result == NULL)
 477         break;
 478     }
 479
 480   return valid_p (result);
 481 }
 482
 483
 484 Dwarf *
 485 dwarf_begin_elf (Elf *elf, Dwarf_Cmd cmd, Elf_Scn *scngrp)
 486 {
 487   GElf_Ehdr *ehdr;
 488   GElf_Ehdr ehdr_mem;
 489
 490   /* Get the ELF header of the file.  We need various pieces of
 491      information from it.  */
 492   ehdr = gelf_getehdr (elf, &ehdr_mem);
 493   if (ehdr == NULL)
 494     {
 495       if (elf_kind (elf) != ELF_K_ELF)
 496         __libdw_seterrno (DWARF_E_NOELF);
 497       else
 498         __libdw_seterrno (DWARF_E_GETEHDR_ERROR);
 499
 500       return NULL;
 501     }
 502
 503
 504   /* Default memory allocation size.  */
 505   size_t mem_default_size = sysconf (_SC_PAGESIZE) - 4 * sizeof (void *);
 506   assert (sizeof (struct Dwarf) < mem_default_size);
 507
 508   /* Allocate the data structure.  */
 509   Dwarf *result = calloc (1, sizeof (Dwarf));
 510   if (unlikely (result == NULL)
 511       || unlikely (Dwarf_Sig8_Hash_init (&result->sig8_hash, 11) < 0))
 512     {
 513       free (result);
 514       __libdw_seterrno (DWARF_E_NOMEM);
 515       return NULL;
 516     }
 517
 518   /* Fill in some values.  */
 519   if ((BYTE_ORDER == LITTLE_ENDIAN && ehdr->e_ident[EI_DATA] == ELFDATA2MSB)
 520       || (BYTE_ORDER == BIG_ENDIAN && ehdr->e_ident[EI_DATA] == ELFDATA2LSB))
 521     result->other_byte_order = true;
 522
 523   result->elf = elf;
 524   result->alt_fd = -1;
 525
 526   /* Initialize the memory handling.  Initial blocks are allocated on first
 527      actual allocation.  */
 528   result->mem_default_size = mem_default_size;
 529   result->oom_handler = __libdw_oom;
 530   if (pthread_rwlock_init(&result->mem_rwl, NULL) != 0)
 531     {
 532       free (result);
 533       __libdw_seterrno (DWARF_E_NOMEM); /* no memory.  */
 534       return NULL;
 535     }
 536   result->mem_stacks = 0;
 537   result->mem_tails = NULL;
 538
 539   if (cmd == DWARF_C_READ || cmd == DWARF_C_RDWR)
 540     {
 541       /* All sections are recognized by name, so pass the section header
 542          string index along to easily get the section names.  */
 543       size_t shstrndx;
 544       if (elf_getshdrstrndx (elf, &shstrndx) != 0)
 545         {
 546           Dwarf_Sig8_Hash_free (&result->sig8_hash);
 547           __libdw_seterrno (DWARF_E_INVALID_ELF);
 548           free (result);
 549           return NULL;
 550         }
 551
 552       /* If the caller provides a section group we get the DWARF
 553          sections only from this section group.  Otherwise we search
 554          for the first section with the required name.  Further
 555          sections with the name are ignored.  The DWARF specification
 556          does not really say this is allowed.  */
 557       if (scngrp == NULL)
 558         return global_read (result, elf, shstrndx);
 559       else
 560         return scngrp_read (result, elf, shstrndx, scngrp);
 561     }
 562   else if (cmd == DWARF_C_WRITE)
 563     {
 564       Dwarf_Sig8_Hash_free (&result->sig8_hash);
 565       __libdw_seterrno (DWARF_E_UNIMPL);
 566       free (result);
 567       return NULL;
 568     }
 569
 570   Dwarf_Sig8_Hash_free (&result->sig8_hash);
 571   __libdw_seterrno (DWARF_E_INVALID_CMD);
 572   free (result);
 573   return NULL;
 574 }
 575 INTDEF(dwarf_begin_elf)